diff --git a/DataAccess/DTOs/Converters/CalculatorToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/CalculatorToDTOConvertStrategy.cs new file mode 100644 index 0000000..e4e69d0 --- /dev/null +++ b/DataAccess/DTOs/Converters/CalculatorToDTOConvertStrategy.cs @@ -0,0 +1,85 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Loggers; +using StructureHelperLogics.NdmCalculations.Analyses.ByForces; +using StructureHelperLogics.NdmCalculations.Cracking; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class CalculatorToDTOConvertStrategy : IConvertStrategy + { + private readonly IConvertStrategy forceCalculatorStrategy; + private readonly IConvertStrategy crackCalculatorStrategy; + + + + public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } + public IShiftTraceLogger TraceLogger { get; set; } + public CalculatorToDTOConvertStrategy( + IConvertStrategy forceCalculatorStrategy, + IConvertStrategy crackCalculatorStrategy) + { + this.forceCalculatorStrategy = forceCalculatorStrategy; + this.crackCalculatorStrategy = crackCalculatorStrategy; + } + + public CalculatorToDTOConvertStrategy() : this ( + new ForceCalculatorToDTOConvertStrategy(), + new CrackCalculatorToDTOConvertStrategy()) + { + + } + + public ICalculator Convert(ICalculator source) + { + try + { + return ProcessCalculators(source); + } + catch (Exception ex) + { + TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Error); + TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error); + throw; + } + } + + private ICalculator ProcessCalculators(ICalculator source) + { + if (source is IForceCalculator forceCalculator) + { + return ProcessForceCalculator(forceCalculator); + } + if (source is ICrackCalculator crackCalculator) + { + return ProcessCrackCalculator(crackCalculator); + } + string errorString = ErrorStrings.ObjectTypeIsUnknownObj(source); + TraceLogger.AddMessage(errorString, TraceLogStatuses.Error); + throw new StructureHelperException(errorString); + } + + private CrackCalculatorDTO ProcessCrackCalculator(ICrackCalculator crackCalculator) + { + crackCalculatorStrategy.ReferenceDictionary = ReferenceDictionary; + crackCalculatorStrategy.TraceLogger = TraceLogger; + var logic = new DictionaryConvertStrategy(this, crackCalculatorStrategy); + return logic.Convert(crackCalculator); + } + + private ForceCalculatorDTO ProcessForceCalculator(IForceCalculator forceCalculator) + { + forceCalculatorStrategy.ReferenceDictionary = ReferenceDictionary; + forceCalculatorStrategy.TraceLogger = TraceLogger; + var logic = new DictionaryConvertStrategy(this, forceCalculatorStrategy); + return logic.Convert(forceCalculator); + } + } +} diff --git a/DataAccess/DTOs/Converters/CrackCalculatorToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/CrackCalculatorToDTOConvertStrategy.cs new file mode 100644 index 0000000..4aff9c6 --- /dev/null +++ b/DataAccess/DTOs/Converters/CrackCalculatorToDTOConvertStrategy.cs @@ -0,0 +1,85 @@ +using DataAccess.DTOs.Converters; +using DataAccess.DTOs.DTOEntities; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Loggers; +using StructureHelperLogics.Models.Materials; +using StructureHelperLogics.NdmCalculations.Analyses.ByForces; +using StructureHelperLogics.NdmCalculations.Cracking; +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class CrackCalculatorToDTOConvertStrategy : IConvertStrategy + { + private readonly IUpdateStrategy updateStrategy; + + public CrackCalculatorToDTOConvertStrategy(IUpdateStrategy updateStrategy) + { + this.updateStrategy = updateStrategy; + } + + public CrackCalculatorToDTOConvertStrategy() : this (new CrackCalculatorUpdateStrategy()) + { + + } + + public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } + public IShiftTraceLogger TraceLogger { get; set; } + + public CrackCalculatorDTO Convert(ICrackCalculator source) + { + try + { + Check(); + return GetNewItem(source); + } + catch (Exception ex) + { + TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Error); + TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error); + throw; + } + } + + private CrackCalculatorDTO GetNewItem(ICrackCalculator source) + { + CrackCalculatorDTO newItem = new() { Id = source.Id}; + updateStrategy.Update(newItem, source); + ProcessForceActions(newItem.InputData, source.InputData); + ProcessPrimitives(newItem.InputData, source.InputData); + return newItem; + } + + private void ProcessPrimitives(IHasPrimitives target, IHasPrimitives source) + { + HasPrimitivesToDTOUpdateStrategy updateStrategy = new() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger + }; + updateStrategy.Update(target, source); + } + + private void ProcessForceActions(IHasForceCombinations target, IHasForceCombinations source) + { + HasForceActionToDTOUpdateStrategy updateStrategy = new() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger + }; + updateStrategy.Update(target, source); + } + + private void Check() + { + var checkLogic = new CheckConvertLogic(this); + checkLogic.Check(); + } + } +} diff --git a/DataAccess/DTOs/Converters/CrossSectionRepositoryToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/CrossSectionRepositoryToDTOConvertStrategy.cs index 9b35ec0..e114964 100644 --- a/DataAccess/DTOs/Converters/CrossSectionRepositoryToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/CrossSectionRepositoryToDTOConvertStrategy.cs @@ -1,9 +1,11 @@ using DataAccess.DTOs.Converters; +using NLog.Targets; using StructureHelper.Models.Materials; using StructureHelperCommon.Infrastructures.Exceptions; using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; using StructureHelperCommon.Models.Analyses; +using StructureHelperCommon.Models.Calculators; using StructureHelperCommon.Models.Forces; using StructureHelperCommon.Models.Loggers; using StructureHelperLogics.Models.CrossSections; @@ -20,23 +22,15 @@ namespace DataAccess.DTOs public class CrossSectionRepositoryToDTOConvertStrategy : IConvertStrategy { private IConvertStrategy materialConvertStrategy; - private IConvertStrategy forceCombinationByFactorConvertStrategy; - private IConvertStrategy forceCombinationListConvertStrategy; - private IConvertStrategy ellipseConvertStrategy = new EllipsePrimitiveDTOConvertStrategy(); - public CrossSectionRepositoryToDTOConvertStrategy(IConvertStrategy materialConvertStrategy, - IConvertStrategy forceCombinationByFactorConvertStrategy, - IConvertStrategy forceCombinationListConvertStrategy) + + public CrossSectionRepositoryToDTOConvertStrategy(IConvertStrategy materialConvertStrategy) { this.materialConvertStrategy = materialConvertStrategy; - this.forceCombinationByFactorConvertStrategy = forceCombinationByFactorConvertStrategy; - this.forceCombinationListConvertStrategy = forceCombinationListConvertStrategy; } public CrossSectionRepositoryToDTOConvertStrategy() : this( - new HeadMaterialToDTOConvertStrategy(), - new ForceCombinationByFactorToDTOConvertStrategy(), - new ForceCombinationListToDTOConvertStrategy()) + new HeadMaterialToDTOConvertStrategy()) { } @@ -54,11 +48,10 @@ namespace DataAccess.DTOs } catch (Exception ex) { - TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Debug); + TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Error); TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error); throw; } - } private CrossSectionRepositoryDTO GetNewRepository(ICrossSectionRepository source) @@ -67,71 +60,42 @@ namespace DataAccess.DTOs { Id = source.Id }; - List forceActions = ProcessForceActions(source); - newItem.ForceActions.AddRange(forceActions); + ProcessForceActions(newItem, source); List materials = ProcessMaterials(source); newItem.HeadMaterials.AddRange(materials); - List primitives = ProcessPrimitives(source); - newItem.Primitives.AddRange(primitives); + ProcessPrimitives(newItem, source); + ProcessCalculators(newItem, source); return newItem; } - private List ProcessPrimitives(ICrossSectionRepository source) + private void ProcessCalculators(IHasCalculators target, IHasCalculators source) { - List primitives = new(); - foreach (var item in source.Primitives) + HasCalculatorsToDTOUpdateStrategy updateStrategy = new() { - if (item is IEllipsePrimitive ellipse) - { - ellipseConvertStrategy.ReferenceDictionary = ReferenceDictionary; - ellipseConvertStrategy.TraceLogger = TraceLogger; - INdmPrimitive ndmPrimitive; - ndmPrimitive = ellipseConvertStrategy.Convert(ellipse); - primitives.Add(ndmPrimitive); - } - } - return primitives; + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger + }; + updateStrategy.Update(target, source); } - private List ProcessForceActions(ICrossSectionRepository source) + private void ProcessPrimitives(IHasPrimitives target, IHasPrimitives source) { - List forceActions = new(); - foreach (var item in source.ForceActions) - { - if (item is IForceCombinationByFactor forceCombinationByFactor) - { - ForceCombinationByFactorDTO forceCombination = GetForceCombinationByFactor(forceCombinationByFactor); - forceActions.Add(forceCombination); - } - else if (item is IForceCombinationList forceCombinationList) - { - ForceCombinationListDTO forceCombination = GetForceCombinationList(forceCombinationList); - forceActions.Add(forceCombination); - } - else - { - throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(item)); - } - } - return forceActions; + HasPrimitivesToDTOUpdateStrategy updateStrategy = new() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger + }; + updateStrategy.Update(target, source); } - private ForceCombinationListDTO GetForceCombinationList(IForceCombinationList forceCombinationList) + private void ProcessForceActions(IHasForceCombinations target, IHasForceCombinations source) { - forceCombinationListConvertStrategy.ReferenceDictionary = ReferenceDictionary; - forceCombinationListConvertStrategy.TraceLogger = TraceLogger; - var convertLogic = new DictionaryConvertStrategy(this, forceCombinationListConvertStrategy); - var forceCombination = convertLogic.Convert(forceCombinationList); - return forceCombination; - } - - private ForceCombinationByFactorDTO GetForceCombinationByFactor(IForceCombinationByFactor forceCombinationByFactor) - { - forceCombinationByFactorConvertStrategy.ReferenceDictionary = ReferenceDictionary; - forceCombinationByFactorConvertStrategy.TraceLogger = TraceLogger; - var convertLogic = new DictionaryConvertStrategy(this, forceCombinationByFactorConvertStrategy); - var forceCombination = convertLogic.Convert(forceCombinationByFactor); - return forceCombination; + HasForceActionToDTOUpdateStrategy updateStrategy = new() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger + }; + updateStrategy.Update(target, source); } private List ProcessMaterials(ICrossSectionRepository source) diff --git a/DataAccess/DTOs/Converters/DesignForceTupleToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/DesignForceTupleToDTOConvertStrategy.cs index 6550252..216dd14 100644 --- a/DataAccess/DTOs/Converters/DesignForceTupleToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/DesignForceTupleToDTOConvertStrategy.cs @@ -43,7 +43,7 @@ namespace DataAccess.DTOs.Converters } catch (Exception ex) { - TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Debug); + TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Error); TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error); throw; } diff --git a/DataAccess/DTOs/Converters/EllipsePrimitiveDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/EllipseNdmPrimitiveToDTOConvertStrategy.cs similarity index 86% rename from DataAccess/DTOs/Converters/EllipsePrimitiveDTOConvertStrategy.cs rename to DataAccess/DTOs/Converters/EllipseNdmPrimitiveToDTOConvertStrategy.cs index a7e42eb..675ec0b 100644 --- a/DataAccess/DTOs/Converters/EllipsePrimitiveDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/EllipseNdmPrimitiveToDTOConvertStrategy.cs @@ -12,17 +12,17 @@ using System.Threading.Tasks; namespace DataAccess.DTOs { - public class EllipsePrimitiveDTOConvertStrategy : IConvertStrategy + public class EllipseNdmPrimitiveToDTOConvertStrategy : IConvertStrategy { - private IUpdateStrategy updateStrategy; + private IUpdateStrategy updateStrategy; private IConvertStrategy rectangleShapeConvertStrategy; private IConvertStrategy ndmElementConvertStrategy; private IConvertStrategy pointConvertStrategy; private IConvertStrategy visualPropsConvertStrategy; private IConvertStrategy divisionConvertStrategy; - public EllipsePrimitiveDTOConvertStrategy( - IUpdateStrategy updateStrategy, + public EllipseNdmPrimitiveToDTOConvertStrategy( + IUpdateStrategy updateStrategy, IConvertStrategy rectangleShapeConvertStrategy, IConvertStrategy ndmElementConvertStrategy, IConvertStrategy pointConvertStrategy, @@ -37,7 +37,7 @@ namespace DataAccess.DTOs this.divisionConvertStrategy = divisionConvertStrategy; } - public EllipsePrimitiveDTOConvertStrategy() : this( + public EllipseNdmPrimitiveToDTOConvertStrategy() : this( new EllipsePrimitiveUpdateStrategy(), new RectangleShapeToDTOConvertStrategy(), new NdmElementDTOConvertStrategy(), @@ -52,13 +52,13 @@ namespace DataAccess.DTOs public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } public IShiftTraceLogger TraceLogger { get; set; } - public EllipseNdmPrimitiveDTO Convert(IEllipsePrimitive source) + public EllipseNdmPrimitiveDTO Convert(IEllipseNdmPrimitive source) { try { Check(); PrepareStrategies(); - return GetNewEllipsePrimitive(source); + return GetNewPrimitive(source); } catch (Exception ex) { @@ -68,7 +68,7 @@ namespace DataAccess.DTOs } } - private EllipseNdmPrimitiveDTO GetNewEllipsePrimitive(IEllipsePrimitive source) + private EllipseNdmPrimitiveDTO GetNewPrimitive(IEllipseNdmPrimitive source) { EllipseNdmPrimitiveDTO newItem = new() { Id = source.Id }; updateStrategy.Update(newItem, source); @@ -98,7 +98,7 @@ namespace DataAccess.DTOs private void Check() { - var checkLogic = new CheckConvertLogic(this); + var checkLogic = new CheckConvertLogic(this); checkLogic.Check(); } } diff --git a/DataAccess/DTOs/Converters/ForceActionToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceActionToDTOConvertStrategy.cs new file mode 100644 index 0000000..de24785 --- /dev/null +++ b/DataAccess/DTOs/Converters/ForceActionToDTOConvertStrategy.cs @@ -0,0 +1,83 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Loggers; + +namespace DataAccess.DTOs.Converters +{ + public class ForceActionToDTOConvertStrategy : IConvertStrategy + { + private IConvertStrategy forceCombinationByFactorConvertStrategy; + private IConvertStrategy forceCombinationListConvertStrategy; + + public ForceActionToDTOConvertStrategy( + IConvertStrategy forceCombinationByFactorConvertStrategy, + IConvertStrategy forceCombinationListConvertStrategy) + { + this.forceCombinationByFactorConvertStrategy = forceCombinationByFactorConvertStrategy; + this.forceCombinationListConvertStrategy = forceCombinationListConvertStrategy; + } + + public ForceActionToDTOConvertStrategy() : this( + new ForceCombinationByFactorToDTOConvertStrategy(), + new ForceCombinationListToDTOConvertStrategy()) + { + + } + + public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } + public IShiftTraceLogger TraceLogger { get; set; } + + public IForceAction Convert(IForceAction source) + { + try + { + return ProcessForceAction(source); + } + catch (Exception ex) + { + TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Error); + TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error); + throw; + } + } + + private IForceAction ProcessForceAction(IForceAction source) + { + if (source is IForceCombinationByFactor forceCombinationByFactor) + { + return GetForceCombinationByFactor(forceCombinationByFactor); + } + else if (source is IForceCombinationList forceCombinationList) + { + return GetForceCombinationList(forceCombinationList); + } + else + { + + string errorString = ErrorStrings.ObjectTypeIsUnknownObj(source); + TraceLogger.AddMessage(errorString, TraceLogStatuses.Error); + throw new StructureHelperException(errorString); + } + } + + private ForceCombinationListDTO GetForceCombinationList(IForceCombinationList forceCombinationList) + { + forceCombinationListConvertStrategy.ReferenceDictionary = ReferenceDictionary; + forceCombinationListConvertStrategy.TraceLogger = TraceLogger; + var convertLogic = new DictionaryConvertStrategy(this, forceCombinationListConvertStrategy); + var forceCombination = convertLogic.Convert(forceCombinationList); + return forceCombination; + } + + private ForceCombinationByFactorDTO GetForceCombinationByFactor(IForceCombinationByFactor forceCombinationByFactor) + { + forceCombinationByFactorConvertStrategy.ReferenceDictionary = ReferenceDictionary; + forceCombinationByFactorConvertStrategy.TraceLogger = TraceLogger; + var convertLogic = new DictionaryConvertStrategy(this, forceCombinationByFactorConvertStrategy); + var forceCombination = convertLogic.Convert(forceCombinationByFactor); + return forceCombination; + } + } +} diff --git a/DataAccess/DTOs/Converters/ForceCalculatorToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceCalculatorToDTOConvertStrategy.cs new file mode 100644 index 0000000..dc4e0ea --- /dev/null +++ b/DataAccess/DTOs/Converters/ForceCalculatorToDTOConvertStrategy.cs @@ -0,0 +1,86 @@ +using DataAccess.DTOs.Converters; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Loggers; +using StructureHelperLogics.NdmCalculations.Analyses.ByForces; +using StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics; +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class ForceCalculatorToDTOConvertStrategy : IConvertStrategy + { + private readonly IUpdateStrategy updateStrategy; + + public ForceCalculatorToDTOConvertStrategy(IUpdateStrategy updateStrategy) + { + this.updateStrategy = updateStrategy; + } + + public ForceCalculatorToDTOConvertStrategy() : this ( + new ForceCalculatorUpdateStrategy() + ) + { + + } + + public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } + public IShiftTraceLogger TraceLogger { get; set; } + + public ForceCalculatorDTO Convert(IForceCalculator source) + { + try + { + Check(); + return GetNewItem(source); + } + catch (Exception ex) + { + TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Error); + TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error); + throw; + } + } + + private ForceCalculatorDTO GetNewItem(IForceCalculator source) + { + ForceCalculatorDTO newItem = new() { Id = source.Id}; + updateStrategy.Update(newItem, source); + ProcessForceActions(newItem.InputData, source.InputData); + ProcessPrimitives(newItem.InputData, source.InputData); + return newItem; + } + + private void ProcessPrimitives(IHasPrimitives target, IHasPrimitives source) + { + HasPrimitivesToDTOUpdateStrategy updateStrategy = new() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger + }; + updateStrategy.Update(target, source); + } + + private void ProcessForceActions(IHasForceCombinations target, IHasForceCombinations source) + { + HasForceActionToDTOUpdateStrategy updateStrategy = new() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger + }; + updateStrategy.Update(target, source); + } + + private void Check() + { + var checkLogic = new CheckConvertLogic(this); + checkLogic.Check(); + } + } +} diff --git a/DataAccess/DTOs/Converters/ForceCombinationByFactorToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceCombinationByFactorToDTOConvertStrategy.cs index a1ae30b..3a16a43 100644 --- a/DataAccess/DTOs/Converters/ForceCombinationByFactorToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/ForceCombinationByFactorToDTOConvertStrategy.cs @@ -54,7 +54,7 @@ namespace DataAccess.DTOs.Converters } catch (Exception ex) { - TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Debug); + TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Error); TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error); throw; } diff --git a/DataAccess/DTOs/Converters/ForceCombinationListToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ForceCombinationListToDTOConvertStrategy.cs index 73abe66..abff0c9 100644 --- a/DataAccess/DTOs/Converters/ForceCombinationListToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/ForceCombinationListToDTOConvertStrategy.cs @@ -1,7 +1,9 @@ using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Forces.Logics; using StructureHelperCommon.Models.Loggers; +using StructureHelperCommon.Models.Shapes; using StructureHelperLogics.Models.CrossSections; using System; using System.Collections.Generic; @@ -15,18 +17,26 @@ namespace DataAccess.DTOs.Converters { private IUpdateStrategy updateStrategy; private IConvertStrategy convertStrategy; + private IUpdateStrategy baseUpdateStrategy; + private IConvertStrategy pointUpdateStrategy; public ForceCombinationListToDTOConvertStrategy( IUpdateStrategy updateStrategy, - IConvertStrategy convertStrategy) + IConvertStrategy convertStrategy, + IUpdateStrategy baseUpdateStrategy, + IConvertStrategy pointUpdateStrategy) { this.updateStrategy = updateStrategy; this.convertStrategy = convertStrategy; + this.baseUpdateStrategy = baseUpdateStrategy; + this.pointUpdateStrategy = pointUpdateStrategy; } public ForceCombinationListToDTOConvertStrategy() : this ( new ForceCombinationListUpdateStrategy(), - new DesignForceTupleToDTOConvertStrategy()) + new DesignForceTupleToDTOConvertStrategy(), + new ForceActionBaseUpdateStrategy(), + new Point2DToDTOConvertStrategy()) { } @@ -44,7 +54,7 @@ namespace DataAccess.DTOs.Converters } catch (Exception ex) { - TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Debug); + TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Error); TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error); throw; } @@ -54,10 +64,12 @@ namespace DataAccess.DTOs.Converters { ForceCombinationListDTO newItem = new() { Id = source.Id}; + baseUpdateStrategy.Update(newItem, source); updateStrategy.Update(newItem, source); convertStrategy.ReferenceDictionary = ReferenceDictionary; convertStrategy.TraceLogger = TraceLogger; var convertLogic = new DictionaryConvertStrategy(this, convertStrategy); + GetNewForcePoint(newItem, source); newItem.DesignForces.Clear(); foreach (var item in source.DesignForces) { @@ -66,6 +78,17 @@ namespace DataAccess.DTOs.Converters return newItem; } + private void GetNewForcePoint(ForceCombinationListDTO newItem, IForceCombinationList source) + { + if (source.ForcePoint is not null) + { + pointUpdateStrategy.ReferenceDictionary = ReferenceDictionary; + pointUpdateStrategy.TraceLogger = TraceLogger; + var convertLogic = new DictionaryConvertStrategy(this, pointUpdateStrategy); + newItem.ForcePoint = convertLogic.Convert(source.ForcePoint); + } + } + private void Check() { var checkLogic = new CheckConvertLogic(this); diff --git a/DataAccess/DTOs/Converters/HasCalculatorsToDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/HasCalculatorsToDTOUpdateStrategy.cs new file mode 100644 index 0000000..cc1e5f2 --- /dev/null +++ b/DataAccess/DTOs/Converters/HasCalculatorsToDTOUpdateStrategy.cs @@ -0,0 +1,52 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Calculators; +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs.Converters +{ + public class HasCalculatorsToDTOUpdateStrategy : IUpdateStrategy + { + private IConvertStrategy convertStrategy; + + public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } + public IShiftTraceLogger TraceLogger { get; set; } + + public HasCalculatorsToDTOUpdateStrategy(IConvertStrategy convertStrategy) + { + this.convertStrategy = convertStrategy; + } + + public HasCalculatorsToDTOUpdateStrategy() : this(new CalculatorToDTOConvertStrategy()) + { + + } + + public void Update(IHasCalculators targetObject, IHasCalculators sourceObject) + { + if (sourceObject.Calculators is null) + { + throw new StructureHelperException(ErrorStrings.ParameterIsNull); + } + targetObject.Calculators.Clear(); + ProcessCalculators(targetObject, sourceObject); + } + + private void ProcessCalculators(IHasCalculators targetObject, IHasCalculators sourceObject) + { + convertStrategy.ReferenceDictionary = ReferenceDictionary; + convertStrategy.TraceLogger = TraceLogger; + foreach (var item in sourceObject.Calculators) + { + ICalculator newItem = convertStrategy.Convert(item); + targetObject.Calculators.Add(newItem); + } + } + } +} diff --git a/DataAccess/DTOs/Converters/HasForceActionToDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/HasForceActionToDTOUpdateStrategy.cs new file mode 100644 index 0000000..17c705d --- /dev/null +++ b/DataAccess/DTOs/Converters/HasForceActionToDTOUpdateStrategy.cs @@ -0,0 +1,55 @@ +using DataAccess.DTOs.Converters; +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Forces; +using StructureHelperLogics.Models.CrossSections; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.CompilerServices; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class HasForceActionToDTOUpdateStrategy : IUpdateStrategy + { + private readonly IConvertStrategy forceActionStrategy; + + public HasForceActionToDTOUpdateStrategy(IConvertStrategy forceActionStrategy) + { + this.forceActionStrategy = forceActionStrategy; + } + + public HasForceActionToDTOUpdateStrategy() : this (new ForceActionToDTOConvertStrategy()) + { + + } + + public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } + public IShiftTraceLogger TraceLogger { get; set; } + + public void Update(IHasForceCombinations targetObject, IHasForceCombinations sourceObject) + { + if (sourceObject.ForceActions is null) + { + throw new StructureHelperException(ErrorStrings.ParameterIsNull); + } + targetObject.ForceActions.Clear(); + targetObject.ForceActions.AddRange(ProcessForceActions(sourceObject.ForceActions)); + } + + private List ProcessForceActions(List source) + { + List forceActions = new(); + forceActionStrategy.ReferenceDictionary = ReferenceDictionary; + forceActionStrategy.TraceLogger = TraceLogger; + foreach (var item in source) + { + forceActions.Add(forceActionStrategy.Convert(item)); + } + return forceActions; + } + } +} diff --git a/DataAccess/DTOs/Converters/HasPrimitivesToDTOUpdateStrategy.cs b/DataAccess/DTOs/Converters/HasPrimitivesToDTOUpdateStrategy.cs new file mode 100644 index 0000000..ea47717 --- /dev/null +++ b/DataAccess/DTOs/Converters/HasPrimitivesToDTOUpdateStrategy.cs @@ -0,0 +1,52 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperLogics.Models.CrossSections; +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs.Converters +{ + public class HasPrimitivesToDTOUpdateStrategy : IUpdateStrategy + { + private IConvertStrategy convertStrategy; + + public HasPrimitivesToDTOUpdateStrategy(IConvertStrategy primitiveConvertStrategy) + { + this.convertStrategy = primitiveConvertStrategy; + } + + public HasPrimitivesToDTOUpdateStrategy() : this(new NdmPrimitiveToDTOConvertStrategy()) + { + + } + + public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } + public IShiftTraceLogger TraceLogger { get; set; } + + public void Update(IHasPrimitives targetObject, IHasPrimitives sourceObject) + { + if (sourceObject.Primitives is null) + { + throw new StructureHelperException(ErrorStrings.ParameterIsNull); + } + targetObject.Primitives.Clear(); + ProcessPrimitives(targetObject, sourceObject); + } + + private void ProcessPrimitives(IHasPrimitives targetObject, IHasPrimitives sourceObject) + { + convertStrategy.ReferenceDictionary = ReferenceDictionary; + convertStrategy.TraceLogger = TraceLogger; + foreach (var item in sourceObject.Primitives) + { + INdmPrimitive primtiveDTO = convertStrategy.Convert(item); + targetObject.Primitives.Add(primtiveDTO); + } + } + } +} diff --git a/DataAccess/DTOs/Converters/NdmElementDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/NdmElementDTOConvertStrategy.cs index ebaec05..08b6e79 100644 --- a/DataAccess/DTOs/Converters/NdmElementDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/NdmElementDTOConvertStrategy.cs @@ -58,7 +58,9 @@ namespace DataAccess.DTOs var headMaterial = convertLogic.Convert(source.HeadMaterial); newItem.HeadMaterial = headMaterial; forceUpdateStrategy.Update(newItem.UsersPrestrain, source.UsersPrestrain); + (newItem.UsersPrestrain as ForceTupleDTO).Id = source.UsersPrestrain.Id; forceUpdateStrategy.Update(newItem.AutoPrestrain, source.AutoPrestrain); + (newItem.AutoPrestrain as ForceTupleDTO).Id = source.AutoPrestrain.Id; return newItem; } diff --git a/DataAccess/DTOs/Converters/NdmPrimitiveToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/NdmPrimitiveToDTOConvertStrategy.cs new file mode 100644 index 0000000..4225843 --- /dev/null +++ b/DataAccess/DTOs/Converters/NdmPrimitiveToDTOConvertStrategy.cs @@ -0,0 +1,97 @@ +using DataAccess.DTOs.DTOEntities; +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Forces; +using StructureHelperLogics.NdmCalculations.Primitives; +using static System.Windows.Forms.VisualStyles.VisualStyleElement; + +namespace DataAccess.DTOs.Converters +{ + public class NdmPrimitiveToDTOConvertStrategy : IConvertStrategy + { + private readonly IConvertStrategy rebarConvertStrategy; + private readonly IConvertStrategy pointConvertStrategy; + private readonly IConvertStrategy ellipseConvertStrategy; + private readonly IConvertStrategy rectangleConvertStrategy; + + public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } + public IShiftTraceLogger TraceLogger { get; set; } + + public NdmPrimitiveToDTOConvertStrategy( + IConvertStrategy rebarConvertStrategy, + IConvertStrategy pointConvertStrategy, + IConvertStrategy ellipseConvertStrategy, + IConvertStrategy rectangleConvertStrategy) + { + this.rebarConvertStrategy = rebarConvertStrategy; + this.pointConvertStrategy = pointConvertStrategy; + this.ellipseConvertStrategy = ellipseConvertStrategy; + this.rectangleConvertStrategy = rectangleConvertStrategy; + } + + public NdmPrimitiveToDTOConvertStrategy() : this( + new RebarNdmPrimitiveToDTOConvertStrategy(), + new PointNdmPrimitiveToDTOConvertStrategy(), + new EllipseNdmPrimitiveToDTOConvertStrategy(), + new RectangleNdmPrimitiveToDTOConvertStrategy()) + { + + } + + + public INdmPrimitive Convert(INdmPrimitive source) + { + if (source is IRebarNdmPrimitive rebar) + { + return ProcessRebar(rebar); + } + if (source is IPointNdmPrimitive point) + { + return ProcessPoint(point); + } + if (source is IEllipseNdmPrimitive ellipse) + { + return ProcessEllipse(ellipse); + } + if (source is IRectangleNdmPrimitive rectangle) + { + return ProcessRectangle(rectangle); + } + TraceLogger.AddMessage("Object type is unknown", TraceLogStatuses.Error); + throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source)); + } + + private RebarNdmPrimitiveDTO ProcessRebar(IRebarNdmPrimitive rebar) + { + rebarConvertStrategy.ReferenceDictionary = ReferenceDictionary; + rebarConvertStrategy.TraceLogger = TraceLogger; + var convertLogic = new DictionaryConvertStrategy(this, rebarConvertStrategy); + return convertLogic.Convert(rebar); + } + + private PointNdmPrimitiveDTO ProcessPoint(IPointNdmPrimitive point) + { + pointConvertStrategy.ReferenceDictionary = ReferenceDictionary; + pointConvertStrategy.TraceLogger = TraceLogger; + var convertLogic = new DictionaryConvertStrategy(this, pointConvertStrategy); + return convertLogic.Convert(point); + } + + private EllipseNdmPrimitiveDTO ProcessEllipse(IEllipseNdmPrimitive ellipse) + { + ellipseConvertStrategy.ReferenceDictionary = ReferenceDictionary; + ellipseConvertStrategy.TraceLogger = TraceLogger; + var convertLogic = new DictionaryConvertStrategy(this, ellipseConvertStrategy); + return convertLogic.Convert(ellipse); + } + + private RectangleNdmPrimitiveDTO ProcessRectangle(IRectangleNdmPrimitive rectangle) + { + rectangleConvertStrategy.ReferenceDictionary = ReferenceDictionary; + rectangleConvertStrategy.TraceLogger = TraceLogger; + var convertLogic = new DictionaryConvertStrategy(this, rectangleConvertStrategy); + return convertLogic.Convert(rectangle); + } + } +} diff --git a/DataAccess/DTOs/Converters/PointNdmPrimitiveToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/PointNdmPrimitiveToDTOConvertStrategy.cs new file mode 100644 index 0000000..961e7c6 --- /dev/null +++ b/DataAccess/DTOs/Converters/PointNdmPrimitiveToDTOConvertStrategy.cs @@ -0,0 +1,88 @@ +using DataAccess.DTOs.Converters; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Loggers; +using StructureHelperCommon.Models.Shapes; +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class PointNdmPrimitiveToDTOConvertStrategy : IConvertStrategy + { + private IUpdateStrategy updateStrategy; + private IConvertStrategy ndmElementConvertStrategy; + private IConvertStrategy pointConvertStrategy; + private IConvertStrategy visualPropsConvertStrategy; + + public PointNdmPrimitiveToDTOConvertStrategy( + IUpdateStrategy updateStrategy, + IConvertStrategy ndmElementConvertStrategy, + IConvertStrategy pointConvertStrategy, + IConvertStrategy visualPropsConvertStrategy) + { + this.updateStrategy = updateStrategy; + this.ndmElementConvertStrategy = ndmElementConvertStrategy; + this.pointConvertStrategy = pointConvertStrategy; + this.visualPropsConvertStrategy = visualPropsConvertStrategy; + } + + public PointNdmPrimitiveToDTOConvertStrategy() : this( + new PointPrimitiveUpdateStrategy(), + new NdmElementDTOConvertStrategy(), + new Point2DToDTOConvertStrategy(), + new VisualPropertyToDTOConvertStrategy() + ) { } + + public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } + public IShiftTraceLogger TraceLogger { get; set; } + + public PointNdmPrimitiveDTO Convert(IPointNdmPrimitive source) + { + try + { + Check(); + PrepareStrategies(); + return GetNewPrimitive(source); + } + catch (Exception ex) + { + TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Debug); + TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error); + throw; + } + } + + private PointNdmPrimitiveDTO GetNewPrimitive(IPointNdmPrimitive source) + { + PointNdmPrimitiveDTO newItem = new() { Id = source.Id}; + updateStrategy.Update(newItem, source); + newItem.NdmElement = ndmElementConvertStrategy.Convert(source.NdmElement); + newItem.Center = pointConvertStrategy.Convert(source.Center); + newItem.VisualProperty = visualPropsConvertStrategy.Convert(source.VisualProperty); + return newItem; + } + + private void PrepareStrategies() + { + ndmElementConvertStrategy.ReferenceDictionary = + pointConvertStrategy.ReferenceDictionary = + visualPropsConvertStrategy.ReferenceDictionary = + ReferenceDictionary; + ndmElementConvertStrategy.TraceLogger = + pointConvertStrategy.TraceLogger = + visualPropsConvertStrategy.TraceLogger = + TraceLogger; + } + + private void Check() + { + var checkLogic = new CheckConvertLogic(this); + checkLogic.Check(); + } + } +} diff --git a/DataAccess/DTOs/Converters/RebarNdmPrimitiveToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/RebarNdmPrimitiveToDTOConvertStrategy.cs new file mode 100644 index 0000000..32ff0bd --- /dev/null +++ b/DataAccess/DTOs/Converters/RebarNdmPrimitiveToDTOConvertStrategy.cs @@ -0,0 +1,99 @@ +using DataAccess.DTOs.Converters; +using DataAccess.DTOs.DTOEntities; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Loggers; +using StructureHelperCommon.Models.Shapes; +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class RebarNdmPrimitiveToDTOConvertStrategy : IConvertStrategy + { + private IUpdateStrategy updateStrategy; + private IConvertStrategy ndmElementConvertStrategy; + private IConvertStrategy pointConvertStrategy; + private IConvertStrategy visualPropsConvertStrategy; + private IConvertStrategy hostPrimitiveConvertStrategy; + + public RebarNdmPrimitiveToDTOConvertStrategy( + IUpdateStrategy updateStrategy, + IConvertStrategy ndmElementConvertStrategy, + IConvertStrategy pointConvertStrategy, + IConvertStrategy visualPropsConvertStrategy) + { + this.updateStrategy = updateStrategy; + this.ndmElementConvertStrategy = ndmElementConvertStrategy; + this.pointConvertStrategy = pointConvertStrategy; + this.visualPropsConvertStrategy = visualPropsConvertStrategy; + } + + public RebarNdmPrimitiveToDTOConvertStrategy() : this( + new RebarNdmPrimitiveUpdateStrategy(), + new NdmElementDTOConvertStrategy(), + new Point2DToDTOConvertStrategy(), + new VisualPropertyToDTOConvertStrategy() + ) { } + + public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } + public IShiftTraceLogger TraceLogger { get; set; } + + public RebarNdmPrimitiveDTO Convert(IRebarNdmPrimitive source) + { + try + { + Check(); + PrepareStrategies(); + return GetNewPrimitive(source); + } + catch (Exception ex) + { + TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Error); + TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error); + throw; + } + } + + private RebarNdmPrimitiveDTO GetNewPrimitive(IRebarNdmPrimitive source) + { + RebarNdmPrimitiveDTO newItem = new() { Id = source.Id }; + //updateStrategy.Update(newItem, source); + newItem.NdmElement = ndmElementConvertStrategy.Convert(source.NdmElement); + newItem.Center = pointConvertStrategy.Convert(source.Center); + newItem.VisualProperty = visualPropsConvertStrategy.Convert(source.VisualProperty); + if (source.HostPrimitive is not null) + { + hostPrimitiveConvertStrategy = new NdmPrimitiveToDTOConvertStrategy(null, null, + new EllipseNdmPrimitiveToDTOConvertStrategy(), + new RectangleNdmPrimitiveToDTOConvertStrategy()); + hostPrimitiveConvertStrategy.ReferenceDictionary = ReferenceDictionary; + hostPrimitiveConvertStrategy.TraceLogger = TraceLogger; + newItem.HostPrimitive = hostPrimitiveConvertStrategy.Convert(source.HostPrimitive); + } + return newItem; + } + + private void PrepareStrategies() + { + ndmElementConvertStrategy.ReferenceDictionary = + pointConvertStrategy.ReferenceDictionary = + visualPropsConvertStrategy.ReferenceDictionary = + ReferenceDictionary; + ndmElementConvertStrategy.TraceLogger = + pointConvertStrategy.TraceLogger = + visualPropsConvertStrategy.TraceLogger = + TraceLogger; + } + + private void Check() + { + var checkLogic = new CheckConvertLogic(this); + checkLogic.Check(); + } + } +} diff --git a/DataAccess/DTOs/Converters/RectangleNdmPrimitiveToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/RectangleNdmPrimitiveToDTOConvertStrategy.cs new file mode 100644 index 0000000..0120a91 --- /dev/null +++ b/DataAccess/DTOs/Converters/RectangleNdmPrimitiveToDTOConvertStrategy.cs @@ -0,0 +1,104 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Loggers; +using StructureHelperCommon.Models.Shapes; +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs.Converters +{ + public class RectangleNdmPrimitiveToDTOConvertStrategy : IConvertStrategy + { + private IUpdateStrategy updateStrategy; + private IConvertStrategy rectangleShapeConvertStrategy; + private IConvertStrategy ndmElementConvertStrategy; + private IConvertStrategy pointConvertStrategy; + private IConvertStrategy visualPropsConvertStrategy; + private IConvertStrategy divisionConvertStrategy; + + public RectangleNdmPrimitiveToDTOConvertStrategy( + IUpdateStrategy updateStrategy, + IConvertStrategy rectangleShapeConvertStrategy, + IConvertStrategy ndmElementConvertStrategy, + IConvertStrategy pointConvertStrategy, + IConvertStrategy visualPropsConvertStrategy, + IConvertStrategy divisionConvertStrategy) + { + this.updateStrategy = updateStrategy; + this.rectangleShapeConvertStrategy = rectangleShapeConvertStrategy; + this.ndmElementConvertStrategy = ndmElementConvertStrategy; + this.pointConvertStrategy = pointConvertStrategy; + this.visualPropsConvertStrategy = visualPropsConvertStrategy; + this.divisionConvertStrategy = divisionConvertStrategy; + } + + public RectangleNdmPrimitiveToDTOConvertStrategy() : this( + new RectanglePrimitiveUpdateStrategy(), + new RectangleShapeToDTOConvertStrategy(), + new NdmElementDTOConvertStrategy(), + new Point2DToDTOConvertStrategy(), + new VisualPropertyToDTOConvertStrategy(), + new DivisionSizeToDTOConvertStrategy() + ) + { + + } + + public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } + public IShiftTraceLogger TraceLogger { get; set; } + + public RectangleNdmPrimitiveDTO Convert(IRectangleNdmPrimitive source) + { + try + { + Check(); + PrepareStrategies(); + return GetNewPrimitive(source); + } + catch (Exception ex) + { + TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Debug); + TraceLogger?.AddMessage(ex.Message, TraceLogStatuses.Error); + throw; + } + } + + private RectangleNdmPrimitiveDTO GetNewPrimitive(IRectangleNdmPrimitive source) + { + RectangleNdmPrimitiveDTO newItem = new() { Id = source.Id }; + updateStrategy.Update(newItem, source); + newItem.NdmElement = ndmElementConvertStrategy.Convert(source.NdmElement); + newItem.RectangleShape = rectangleShapeConvertStrategy.Convert(source.Shape as IRectangleShape); + newItem.Center = pointConvertStrategy.Convert(source.Center); + newItem.VisualProperty = visualPropsConvertStrategy.Convert(source.VisualProperty); + newItem.DivisionSize = divisionConvertStrategy.Convert(source.DivisionSize); + return newItem; + } + + private void PrepareStrategies() + { + rectangleShapeConvertStrategy.ReferenceDictionary = + ndmElementConvertStrategy.ReferenceDictionary = + pointConvertStrategy.ReferenceDictionary = + visualPropsConvertStrategy.ReferenceDictionary = + divisionConvertStrategy.ReferenceDictionary = + ReferenceDictionary; + rectangleShapeConvertStrategy.TraceLogger = + ndmElementConvertStrategy.TraceLogger = + pointConvertStrategy.TraceLogger = + visualPropsConvertStrategy.TraceLogger = + divisionConvertStrategy.TraceLogger = + TraceLogger; + } + + private void Check() + { + var checkLogic = new CheckConvertLogic(this); + checkLogic.Check(); + } + } +} diff --git a/DataAccess/DTOs/DTOEntities/AccuracyDTO.cs b/DataAccess/DTOs/DTOEntities/AccuracyDTO.cs new file mode 100644 index 0000000..e3108a5 --- /dev/null +++ b/DataAccess/DTOs/DTOEntities/AccuracyDTO.cs @@ -0,0 +1,21 @@ +using Newtonsoft.Json; +using StructureHelperCommon.Models.Calculators; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs.DTOEntities +{ + public class AccuracyDTO : IAccuracy + { + [JsonProperty("Id")] + public Guid Id { get; set; } + [JsonProperty("IterationAccuracy")] + public double IterationAccuracy { get; set; } + [JsonProperty("MaxIterationCount")] + public int MaxIterationCount { get; set; } + + } +} diff --git a/DataAccess/DTOs/DTOEntities/CompressedMemberDTO.cs b/DataAccess/DTOs/DTOEntities/CompressedMemberDTO.cs new file mode 100644 index 0000000..922da97 --- /dev/null +++ b/DataAccess/DTOs/DTOEntities/CompressedMemberDTO.cs @@ -0,0 +1,34 @@ +using Newtonsoft.Json; +using StructureHelperCommon.Models.Sections; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class CompressedMemberDTO : ICompressedMember + { + [JsonProperty("Id")] + public Guid Id { get; set; } + [JsonProperty("Bucling")] + public bool Buckling { get; set; } + [JsonProperty("GeometryLength")] + public double GeometryLength { get; set; } + [JsonProperty("LengthFactorX")] + public double LengthFactorX { get; set; } + [JsonProperty("DiagramFactorX")] + public double DiagramFactorX { get; set; } + [JsonProperty("LengthFactorY")] + public double LengthFactorY { get; set; } + [JsonProperty("DiagramFactorY")] + public double DiagramFactorY { get; set; } + + + public object Clone() + { + throw new NotImplementedException(); + } + } +} diff --git a/DataAccess/DTOs/DTOEntities/CrackCalculatorDTO.cs b/DataAccess/DTOs/DTOEntities/CrackCalculatorDTO.cs new file mode 100644 index 0000000..42149db --- /dev/null +++ b/DataAccess/DTOs/DTOEntities/CrackCalculatorDTO.cs @@ -0,0 +1,37 @@ +using Newtonsoft.Json; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Calculators; +using StructureHelperLogics.NdmCalculations.Cracking; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class CrackCalculatorDTO : ICrackCalculator + { + [JsonProperty("Id")] + public Guid Id { get; set; } + [JsonProperty("Name")] + public string Name { get; set; } + [JsonProperty("InputData")] + public ICrackCalculatorInputData InputData { get; set; } = new CrackCalculatorInputDataDTO(); + [JsonIgnore] + public IResult Result { get; } + [JsonIgnore] + public IShiftTraceLogger? TraceLogger { get; set; } + + + public object Clone() + { + throw new NotImplementedException(); + } + + public void Run() + { + throw new NotImplementedException(); + } + } +} diff --git a/DataAccess/DTOs/DTOEntities/CrackCalculatorInputDataDTO.cs b/DataAccess/DTOs/DTOEntities/CrackCalculatorInputDataDTO.cs new file mode 100644 index 0000000..8ae3ad1 --- /dev/null +++ b/DataAccess/DTOs/DTOEntities/CrackCalculatorInputDataDTO.cs @@ -0,0 +1,20 @@ +using Newtonsoft.Json; +using StructureHelperCommon.Models.Forces; +using StructureHelperLogics.NdmCalculations.Cracking; +using StructureHelperLogics.NdmCalculations.Primitives; + +namespace DataAccess.DTOs +{ + public class CrackCalculatorInputDataDTO : ICrackCalculatorInputData + { + [JsonProperty("Id")] + public Guid Id { get; set; } + [JsonProperty("ForceActions")] + public List ForceActions { get; set; } = new(); + [JsonProperty("ForcePrimitives")] + public List Primitives { get; set; } = new(); + [JsonProperty("UserCrackInputData")] + public IUserCrackInputData UserCrackInputData { get; set; } = new UserCrackInputDataDTO(); + + } +} diff --git a/DataAccess/DTOs/DTOEntities/EllipseNdmPrimitiveDTO.cs b/DataAccess/DTOs/DTOEntities/EllipseNdmPrimitiveDTO.cs index d3490a3..fea2655 100644 --- a/DataAccess/DTOs/DTOEntities/EllipseNdmPrimitiveDTO.cs +++ b/DataAccess/DTOs/DTOEntities/EllipseNdmPrimitiveDTO.cs @@ -12,7 +12,7 @@ using System.Threading.Tasks; namespace DataAccess.DTOs { - public class EllipseNdmPrimitiveDTO : IEllipsePrimitive + public class EllipseNdmPrimitiveDTO : IEllipseNdmPrimitive { private IRectangleShape shape = new RectangleShapeDTO(); @@ -36,14 +36,15 @@ namespace DataAccess.DTOs public IPoint2D Center { get; set; } = new Point2DDTO(); [JsonProperty("DivisionSize")] public IDivisionSize DivisionSize { get; set; } = new DivisionSizeDTO(); + [JsonProperty("RotationAngle")] + public double RotationAngle { get; set; } [JsonIgnore] public double Width { get; set; } [JsonIgnore] public double Height {get; set; } [JsonIgnore] - public double Angle { get; set; } - [JsonIgnore] public ICrossSection? CrossSection { get; set; } + public object Clone() { throw new NotImplementedException(); diff --git a/DataAccess/DTOs/DTOEntities/ForceCalculatorDTO.cs b/DataAccess/DTOs/DTOEntities/ForceCalculatorDTO.cs new file mode 100644 index 0000000..216766f --- /dev/null +++ b/DataAccess/DTOs/DTOEntities/ForceCalculatorDTO.cs @@ -0,0 +1,38 @@ +using Newtonsoft.Json; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Calculators; +using StructureHelperLogics.NdmCalculations.Analyses.ByForces; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class ForceCalculatorDTO : IForceCalculator + { + [JsonProperty("Id")] + public Guid Id { get; set; } + [JsonProperty("Name")] + public string Name { get; set; } + [JsonProperty("InputData")] + public IForceCalculatorInputData InputData { get; set; } = new ForceCalculatorInputDataDTO(); + [JsonIgnore] + public IShiftTraceLogger? TraceLogger { get; set; } + [JsonIgnore] + public Action ActionToOutputResults { get; set; } + [JsonIgnore] + public IResult Result => throw new NotImplementedException(); + + public object Clone() + { + throw new NotImplementedException(); + } + + public void Run() + { + throw new NotImplementedException(); + } + } +} diff --git a/DataAccess/DTOs/DTOEntities/ForceCalculatorInputDataDTO.cs b/DataAccess/DTOs/DTOEntities/ForceCalculatorInputDataDTO.cs new file mode 100644 index 0000000..5b42c3d --- /dev/null +++ b/DataAccess/DTOs/DTOEntities/ForceCalculatorInputDataDTO.cs @@ -0,0 +1,37 @@ +using DataAccess.DTOs.DTOEntities; +using Newtonsoft.Json; +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Sections; +using StructureHelperLogics.NdmCalculations.Analyses.ByForces; +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class ForceCalculatorInputDataDTO : IForceCalculatorInputData + { + [JsonProperty("Id")] + public Guid Id { get; set; } + [JsonProperty("ForceActions")] + public List ForceActions { get; set; } = new(); + [JsonProperty("Primitives")] + public List Primitives { get; set; } = new(); + [JsonProperty("LimitStatesList")] + public List LimitStatesList { get; set; } = new(); + [JsonProperty("CalcTermList")] + public List CalcTermsList { get; set; } = new(); + [JsonProperty("Accuracy")] + public IAccuracy Accuracy { get; set; } = new AccuracyDTO(); + [JsonProperty("CompressedMember")] + public ICompressedMember CompressedMember { get; set; } = new CompressedMemberDTO(); + [JsonIgnore] + public List ForceCombinationLists { get; set; } = new(); + + } +} diff --git a/DataAccess/DTOs/DTOEntities/ForceCombinationListDTO.cs b/DataAccess/DTOs/DTOEntities/ForceCombinationListDTO.cs index 913261d..0db8327 100644 --- a/DataAccess/DTOs/DTOEntities/ForceCombinationListDTO.cs +++ b/DataAccess/DTOs/DTOEntities/ForceCombinationListDTO.cs @@ -18,7 +18,7 @@ namespace DataAccess.DTOs [JsonProperty("SetInGravityCenter")] public bool SetInGravityCenter { get; set; } [JsonProperty("ForcePoint")] - public IPoint2D ForcePoint { get; set; } + public IPoint2D ForcePoint { get; set; } = new Point2DDTO(); [JsonProperty("DesignForces")] public List DesignForces { get; set; } = new(); diff --git a/DataAccess/DTOs/DTOEntities/PointNdmPrimitiveDTO.cs b/DataAccess/DTOs/DTOEntities/PointNdmPrimitiveDTO.cs new file mode 100644 index 0000000..1c176c0 --- /dev/null +++ b/DataAccess/DTOs/DTOEntities/PointNdmPrimitiveDTO.cs @@ -0,0 +1,53 @@ +using LoaderCalculator.Data.Ndms; +using Newtonsoft.Json; +using StructureHelperCommon.Models.Shapes; +using StructureHelperLogics.Models.CrossSections; +using StructureHelperLogics.NdmCalculations.Primitives; +using StructureHelperLogics.NdmCalculations.Triangulations; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class PointNdmPrimitiveDTO : IPointNdmPrimitive + { + [JsonProperty("Id")] + public Guid Id { get; set; } + [JsonProperty("Name")] + public string? Name { get; set; } + [JsonProperty("NdmElement")] + public INdmElement NdmElement { get; set; } = new NdmElementDTO(); + [JsonProperty("VisualProperty")] + public IVisualProperty VisualProperty { get; set; } = new VisualPropertyDTO(); + [JsonProperty("Center")] + public IPoint2D Center { get; set; } = new Point2DDTO(); + [JsonProperty("RotationAngle")] + public double RotationAngle { get; set; } = 0d; + [JsonProperty("Area")] + public double Area { get; set; } = 0d; + + [JsonIgnore] + public ICrossSection? CrossSection { get; set; } + [JsonIgnore] + public IShape Shape { get; set; } + + + public object Clone() + { + throw new NotImplementedException(); + } + + public IEnumerable GetNdms(ITriangulationOptions triangulationOptions) + { + throw new NotImplementedException(); + } + + public List GetValuePoints() + { + throw new NotImplementedException(); + } + } +} diff --git a/DataAccess/DTOs/DTOEntities/RebarNdmPrimitiveDTO.cs b/DataAccess/DTOs/DTOEntities/RebarNdmPrimitiveDTO.cs new file mode 100644 index 0000000..9a7817b --- /dev/null +++ b/DataAccess/DTOs/DTOEntities/RebarNdmPrimitiveDTO.cs @@ -0,0 +1,64 @@ +using LoaderCalculator.Data.Ndms; +using Newtonsoft.Json; +using StructureHelperCommon.Models.Shapes; +using StructureHelperLogics.Models.CrossSections; +using StructureHelperLogics.NdmCalculations.Primitives; +using StructureHelperLogics.NdmCalculations.Triangulations; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs.DTOEntities +{ + public class RebarNdmPrimitiveDTO : IRebarNdmPrimitive + { + [JsonProperty("Id")] + public Guid Id { get; set; } + [JsonProperty("Name")] + public string? Name { get; set; } + [JsonIgnore] + public IShape Shape { get; set; } + [JsonProperty("NdmElement")] + public INdmElement NdmElement { get; set; } = new NdmElementDTO(); + [JsonIgnore] + public ICrossSection? CrossSection { get; set; } + [JsonProperty("VisualProperty")] + public IVisualProperty VisualProperty { get; set; } = new VisualPropertyDTO(); + [JsonProperty("Center")] + public IPoint2D Center { get; set; } = new Point2DDTO(); + [JsonProperty("RotationAngle")] + public double RotationAngle { get; set; } = 0d; + [JsonProperty("Area")] + public double Area { get; set; } = 0d; + + + public INdmPrimitive? HostPrimitive { get; set; } + + public object Clone() + { + throw new NotImplementedException(); + } + + public Ndm GetConcreteNdm(ITriangulationOptions triangulationOptions) + { + throw new NotImplementedException(); + } + + public IEnumerable GetNdms(ITriangulationOptions triangulationOptions) + { + throw new NotImplementedException(); + } + + public RebarNdm GetRebarNdm(ITriangulationOptions triangulationOptions) + { + throw new NotImplementedException(); + } + + public List GetValuePoints() + { + throw new NotImplementedException(); + } + } +} diff --git a/DataAccess/DTOs/DTOEntities/RectangleNdmPrimitiveDTO.cs b/DataAccess/DTOs/DTOEntities/RectangleNdmPrimitiveDTO.cs new file mode 100644 index 0000000..e858f41 --- /dev/null +++ b/DataAccess/DTOs/DTOEntities/RectangleNdmPrimitiveDTO.cs @@ -0,0 +1,68 @@ +using LoaderCalculator.Data.Ndms; +using Newtonsoft.Json; +using StructureHelperCommon.Models.Shapes; +using StructureHelperLogics.Models.CrossSections; +using StructureHelperLogics.NdmCalculations.Primitives; +using StructureHelperLogics.NdmCalculations.Triangulations; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class RectangleNdmPrimitiveDTO : IRectangleNdmPrimitive + { + private IRectangleShape shape = new RectangleShapeDTO(); + + [JsonProperty("Id")] + public Guid Id { get; set; } + [JsonProperty("Name")] + public string? Name { get; set; } + [JsonProperty("RectangleShape")] + public IRectangleShape RectangleShape + { + get => shape; + set => shape = value; + } + [JsonIgnore] + public IShape Shape => shape; + [JsonProperty("NdmElement")] + public INdmElement NdmElement { get; set; } = new NdmElementDTO(); + [JsonProperty("VisualProperty")] + public IVisualProperty VisualProperty { get; set; } = new VisualPropertyDTO(); + [JsonProperty("Center")] + public IPoint2D Center { get; set; } = new Point2DDTO(); + [JsonProperty("DivisionSize")] + public IDivisionSize DivisionSize { get; set; } = new DivisionSizeDTO(); + [JsonProperty("RotationAngle")] + public double RotationAngle { get; set; } + [JsonIgnore] + public double Width { get; set; } + [JsonIgnore] + public double Height { get; set; } + [JsonIgnore] + public ICrossSection? CrossSection { get; set; } + + public object Clone() + { + throw new NotImplementedException(); + } + + public IEnumerable GetNdms(ITriangulationOptions triangulationOptions) + { + throw new NotImplementedException(); + } + + public List GetValuePoints() + { + throw new NotImplementedException(); + } + + public bool IsPointInside(IPoint2D point) + { + throw new NotImplementedException(); + } + } +} diff --git a/DataAccess/DTOs/DTOEntities/RectangleShapeDTO.cs b/DataAccess/DTOs/DTOEntities/RectangleShapeDTO.cs index d46f87a..4303cef 100644 --- a/DataAccess/DTOs/DTOEntities/RectangleShapeDTO.cs +++ b/DataAccess/DTOs/DTOEntities/RectangleShapeDTO.cs @@ -16,8 +16,6 @@ namespace DataAccess.DTOs public double Width { get; set; } [JsonProperty("Height")] public double Height { get; set; } - [JsonProperty("Angle")] - public double Angle { get; set; } } } diff --git a/DataAccess/DTOs/DTOEntities/TypeBinderListFactory.cs b/DataAccess/DTOs/DTOEntities/TypeBinderListFactory.cs index 34ad2e7..e4feeac 100644 --- a/DataAccess/DTOs/DTOEntities/TypeBinderListFactory.cs +++ b/DataAccess/DTOs/DTOEntities/TypeBinderListFactory.cs @@ -1,4 +1,6 @@ -using StructureHelper.Models.Materials; +using DataAccess.DTOs.DTOEntities; +using StructureHelper.Models.Materials; +using StructureHelperCommon.Infrastructures.Enums; using StructureHelperCommon.Infrastructures.Exceptions; using StructureHelperCommon.Models.Analyses; using StructureHelperCommon.Models.Calculators; @@ -34,18 +36,24 @@ namespace DataAccess.DTOs private static List<(Type type, string name)> GetVersionV1() { - return new List<(Type type, string name)> + List<(Type type, string name)> newList = new List<(Type type, string name)> { + { (typeof(AccuracyDTO), "Accuracy") }, { (typeof(ConcreteLibMaterialDTO), "ConcreteLibMaterial") }, + { (typeof(CompressedMemberDTO), "CompressedMember") }, + { (typeof(CrackCalculatorDTO), "CrackCalculator") }, + { (typeof(CrackCalculatorInputDataDTO), "CrackCalculatorInputData") }, { (typeof(CrossSectionDTO), "CrossSection") }, { (typeof(CrossSectionNdmAnalysisDTO), "CrossSectionNdmAnalysis") }, { (typeof(CrossSectionRepositoryDTO), "CrossSectionRepository") }, { (typeof(DateVersionDTO), "DateVersion") }, - { (typeof(EllipseNdmPrimitiveDTO), "EllipseNdmPrimitive") }, { (typeof(DesignForceTupleDTO), "DesignForceTuple") }, { (typeof(DivisionSizeDTO), "DivisionSize") }, { (typeof(ElasticMaterialDTO), "ElasticMaterial") }, + { (typeof(EllipseNdmPrimitiveDTO), "EllipseNdmPrimitive") }, { (typeof(FileVersionDTO), "FileVersion") }, + { (typeof(ForceCalculatorDTO), "ForceCalculator") }, + { (typeof(ForceCalculatorInputDataDTO), "ForceCalculatorInputData") }, { (typeof(ForceCombinationByFactorDTO), "ForceCombinationByFactor") }, { (typeof(ForceCombinationListDTO), "ForceCombinationList") }, { (typeof(ForceTupleDTO), "ForceTuple") }, @@ -54,25 +62,32 @@ namespace DataAccess.DTOs { (typeof(MaterialSafetyFactorDTO), "MaterialSafetyFactor") }, { (typeof(NdmElementDTO), "NdmElement") }, { (typeof(IVisualAnalysis), "IVisualAnalysis") }, + { (typeof(List), "ListOfCalcTerms") }, { (typeof(List), "ListOfICalculator") }, { (typeof(List), "ListOfIDateVersion") }, { (typeof(List), "ListOfIDesignForceTuple") }, { (typeof(List), "ListOfIForceAction") }, { (typeof(List), "ListOfIHeadMaterial") }, + { (typeof(List), "ListOfLimitState") }, { (typeof(List), "ListOfMaterialSafetyFactor") }, { (typeof(List), "ListOfMaterialPartialFactor") }, { (typeof(List), "ListOfINdmPrimitive") }, { (typeof(List), "ListOfPartialFactor") }, { (typeof(List), "ListOfIVisualAnalysis") }, { (typeof(Point2DDTO), "Point2D") }, + { (typeof(PointNdmPrimitiveDTO), "PointNdmPrimitive") }, { (typeof(ProjectDTO), "Project") }, + { (typeof(RebarNdmPrimitiveDTO), "RebarNdmPrimitive") }, + { (typeof(RectangleNdmPrimitiveDTO), "RectangleNdmPrimitive") }, { (typeof(RectangleShapeDTO), "RectangleShape") }, { (typeof(ReinforcementLibMaterialDTO), "ReinforcementLibMaterial") }, { (typeof(MaterialPartialFactorDTO), "MaterialPartialFactor") }, { (typeof(VersionProcessorDTO), "VersionProcessor") }, { (typeof(VisualAnalysisDTO), "VisualAnalysis") }, { (typeof(VisualPropertyDTO), "VisualProperty") }, + { (typeof(UserCrackInputDataDTO), "UserCrackInputData") }, }; + return newList; } } } diff --git a/DataAccess/DTOs/DTOEntities/UserCrackInputDataDTO.cs b/DataAccess/DTOs/DTOEntities/UserCrackInputDataDTO.cs new file mode 100644 index 0000000..19cff8a --- /dev/null +++ b/DataAccess/DTOs/DTOEntities/UserCrackInputDataDTO.cs @@ -0,0 +1,29 @@ +using Newtonsoft.Json; +using StructureHelperLogics.NdmCalculations.Cracking; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class UserCrackInputDataDTO : IUserCrackInputData + { + [JsonProperty("Id")] + public Guid Id { get; set; } + [JsonProperty("LengthBetweenCracks")] + public double LengthBetweenCracks { get; set; } + [JsonProperty("SetLengthBetweenCracks")] + public bool SetLengthBetweenCracks { get; set; } + [JsonProperty("SetSofteningFactors")] + public bool SetSofteningFactor { get; set; } + [JsonProperty("SofteningFactors")] + public double SofteningFactor { get; set; } + [JsonProperty("UltimateLongCrackWidths")] + public double UltimateLongCrackWidth { get; set; } + [JsonProperty("UltimateShortCrackWidths")] + public double UltimateShortCrackWidth { get; set; } + + } +} diff --git a/StructureHelper/Infrastructure/UI/DataContexts/CircleViewPrimitive.cs b/StructureHelper/Infrastructure/UI/DataContexts/CircleViewPrimitive.cs index 9644ca6..9923862 100644 --- a/StructureHelper/Infrastructure/UI/DataContexts/CircleViewPrimitive.cs +++ b/StructureHelper/Infrastructure/UI/DataContexts/CircleViewPrimitive.cs @@ -12,7 +12,7 @@ namespace StructureHelper.Infrastructure.UI.DataContexts { public class CircleViewPrimitive : PrimitiveBase, IHasCenter { - IEllipsePrimitive primitive; + IEllipseNdmPrimitive primitive; public double Diameter { get @@ -31,11 +31,11 @@ namespace StructureHelper.Infrastructure.UI.DataContexts public CircleViewPrimitive(INdmPrimitive primitive) : base(primitive) { - if (primitive is not IEllipsePrimitive) + if (primitive is not IEllipseNdmPrimitive) { - throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $"\nExpected: {nameof(IEllipsePrimitive)}, But was: {nameof(primitive)}"); + throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $"\nExpected: {nameof(IEllipseNdmPrimitive)}, But was: {nameof(primitive)}"); } - var circle = primitive as IEllipsePrimitive; + var circle = primitive as IEllipseNdmPrimitive; this.primitive = circle; DivisionViewModel = new HasDivisionViewModel(circle.DivisionSize); } diff --git a/StructureHelper/Infrastructure/UI/DataContexts/PointViewPrimitive.cs b/StructureHelper/Infrastructure/UI/DataContexts/PointViewPrimitive.cs index bc5d969..d539543 100644 --- a/StructureHelper/Infrastructure/UI/DataContexts/PointViewPrimitive.cs +++ b/StructureHelper/Infrastructure/UI/DataContexts/PointViewPrimitive.cs @@ -11,7 +11,7 @@ namespace StructureHelper.Infrastructure.UI.DataContexts { public class PointViewPrimitive : PrimitiveBase, IHasCenter { - IPointPrimitive primitive; + IPointNdmPrimitive primitive; public double Area { get => primitive.Area; @@ -31,7 +31,7 @@ namespace StructureHelper.Infrastructure.UI.DataContexts get => DeltaY - Diameter / 2d; } - public PointViewPrimitive(IPointPrimitive _primitive) : base(_primitive) + public PointViewPrimitive(IPointNdmPrimitive _primitive) : base(_primitive) { primitive = _primitive; } diff --git a/StructureHelper/Infrastructure/UI/DataContexts/PrimitiveOperations.cs b/StructureHelper/Infrastructure/UI/DataContexts/PrimitiveOperations.cs index 37d1924..436961b 100644 --- a/StructureHelper/Infrastructure/UI/DataContexts/PrimitiveOperations.cs +++ b/StructureHelper/Infrastructure/UI/DataContexts/PrimitiveOperations.cs @@ -25,24 +25,24 @@ namespace StructureHelper.Infrastructure.UI.DataContexts public static PrimitiveBase ConvertNdmPrimitiveToPrimitiveBase(INdmPrimitive primitive) { PrimitiveBase viewItem; - if (primitive is IRectanglePrimitive) + if (primitive is IRectangleNdmPrimitive) { - var rect = primitive as IRectanglePrimitive; + var rect = primitive as IRectangleNdmPrimitive; viewItem = new RectangleViewPrimitive(rect); } - else if (primitive is IEllipsePrimitive) + else if (primitive is IEllipseNdmPrimitive) { - var circle = primitive as IEllipsePrimitive; + var circle = primitive as IEllipseNdmPrimitive; viewItem = new CircleViewPrimitive(circle); } - else if (primitive is IPointPrimitive & primitive is not RebarPrimitive) + else if (primitive is IPointNdmPrimitive & primitive is not RebarNdmPrimitive) { - var point = primitive as IPointPrimitive; + var point = primitive as IPointNdmPrimitive; viewItem = new PointViewPrimitive(point); } - else if (primitive is RebarPrimitive) + else if (primitive is RebarNdmPrimitive) { - var point = primitive as RebarPrimitive; + var point = primitive as RebarNdmPrimitive; viewItem = new ReinforcementViewPrimitive(point); } else throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknown + $". Actual type: {primitive.GetType()}"); diff --git a/StructureHelper/Infrastructure/UI/DataContexts/RectangleViewPrimitive.cs b/StructureHelper/Infrastructure/UI/DataContexts/RectangleViewPrimitive.cs index e9d7b31..052ef67 100644 --- a/StructureHelper/Infrastructure/UI/DataContexts/RectangleViewPrimitive.cs +++ b/StructureHelper/Infrastructure/UI/DataContexts/RectangleViewPrimitive.cs @@ -5,7 +5,7 @@ namespace StructureHelper.Infrastructure.UI.DataContexts { public class RectangleViewPrimitive : PrimitiveBase, IHasCenter { - private IRectanglePrimitive primitive; + private IRectangleNdmPrimitive primitive; public override double PrimitiveWidth { @@ -37,7 +37,7 @@ namespace StructureHelper.Infrastructure.UI.DataContexts get => DeltaY - primitive.Height / 2d; } - public RectangleViewPrimitive(IRectanglePrimitive _primitive) : base(_primitive) + public RectangleViewPrimitive(IRectangleNdmPrimitive _primitive) : base(_primitive) { primitive = _primitive; DivisionViewModel = new HasDivisionViewModel(primitive.DivisionSize); diff --git a/StructureHelper/Infrastructure/UI/DataContexts/ReinforcementViewPrimitive.cs b/StructureHelper/Infrastructure/UI/DataContexts/ReinforcementViewPrimitive.cs index e644160..555d1e2 100644 --- a/StructureHelper/Infrastructure/UI/DataContexts/ReinforcementViewPrimitive.cs +++ b/StructureHelper/Infrastructure/UI/DataContexts/ReinforcementViewPrimitive.cs @@ -9,7 +9,7 @@ namespace StructureHelper.Infrastructure.UI.DataContexts { public class ReinforcementViewPrimitive : PointViewPrimitive, IHasHostPrimitive { - RebarPrimitive primitive; + RebarNdmPrimitive primitive; public INdmPrimitive HostPrimitive { @@ -21,7 +21,7 @@ namespace StructureHelper.Infrastructure.UI.DataContexts } } - public ReinforcementViewPrimitive(RebarPrimitive _primitive) : base(_primitive) + public ReinforcementViewPrimitive(RebarNdmPrimitive _primitive) : base(_primitive) { primitive = _primitive; } diff --git a/StructureHelper/Services/ResultViewers/ShowAnchorageResult.cs b/StructureHelper/Services/ResultViewers/ShowAnchorageResult.cs index 4f90733..6f8da63 100644 --- a/StructureHelper/Services/ResultViewers/ShowAnchorageResult.cs +++ b/StructureHelper/Services/ResultViewers/ShowAnchorageResult.cs @@ -50,9 +50,9 @@ namespace StructureHelper.Services.ResultViewers List primitives = new List(); foreach (var item in ndmPrimitives) { - if (item is RebarPrimitive) + if (item is RebarNdmPrimitive) { - var primitive = item as RebarPrimitive; + var primitive = item as RebarNdmPrimitive; var inputData = InputDataFactory.GetInputData(primitive, strainMatrix, limitState, calcTerm, 1d); if (fullStrength == true) { @@ -73,9 +73,9 @@ namespace StructureHelper.Services.ResultViewers List primitives = new List(); foreach (var item in ndmPrimitives) { - if (item is RebarPrimitive) + if (item is RebarNdmPrimitive) { - var primitive = item as RebarPrimitive; + var primitive = item as RebarNdmPrimitive; var inputData = InputDataFactory.GetInputData(primitive, strainMatrix, limitState, calcTerm, 1d); var calculator = new AnchorageCalculator(inputData); var val = calculator.GetBaseDevLength() * UnitConstants.Length; @@ -92,9 +92,9 @@ namespace StructureHelper.Services.ResultViewers List primitives = new List(); foreach (var item in ndmPrimitives) { - if (item is RebarPrimitive) + if (item is RebarNdmPrimitive) { - var primitive = item as RebarPrimitive; + var primitive = item as RebarNdmPrimitive; var inputData = InputDataFactory.GetInputData(primitive, strainMatrix, limitState, calcTerm, 1d); if (fullStrength == true) { @@ -116,9 +116,9 @@ namespace StructureHelper.Services.ResultViewers List primitives = new List(); foreach (var item in ndmPrimitives) { - if (item is RebarPrimitive) + if (item is RebarNdmPrimitive) { - var primitive = item as RebarPrimitive; + var primitive = item as RebarNdmPrimitive; var inputData = InputDataFactory.GetInputData(primitive, strainMatrix, limitState, calcTerm, lapperdCountRate); if (fullStrength == true) { @@ -134,7 +134,7 @@ namespace StructureHelper.Services.ResultViewers return primitiveSet; } - private static FieldVisualizer.Entities.Values.Primitives.CirclePrimitive GetValuePrimitive(IPointPrimitive primitive, double val) + private static FieldVisualizer.Entities.Values.Primitives.CirclePrimitive GetValuePrimitive(IPointNdmPrimitive primitive, double val) { var valuePrimitive = new FieldVisualizer.Entities.Values.Primitives.CirclePrimitive() { diff --git a/StructureHelper/Windows/MainWindow/Analyses/FileLogic.cs b/StructureHelper/Windows/MainWindow/Analyses/FileLogic.cs index d7d4dcd..b096d5c 100644 --- a/StructureHelper/Windows/MainWindow/Analyses/FileLogic.cs +++ b/StructureHelper/Windows/MainWindow/Analyses/FileLogic.cs @@ -136,7 +136,7 @@ namespace StructureHelper.Windows.MainWindow } private void ShowEntries() { - var filteredEntries = traceLogger.TraceLoggerEntries.Where(x => x.Priority <= 300); + var filteredEntries = traceLogger.TraceLoggerEntries.Where(x => x.Priority < 300); if (filteredEntries.Any()) { var wnd = new TraceDocumentView(traceLogger); diff --git a/StructureHelper/Windows/ViewModels/Calculations/Calculators/ForceCalculatorInputDataVM.cs b/StructureHelper/Windows/ViewModels/Calculations/Calculators/ForceCalculatorInputDataVM.cs index 6160d31..c021947 100644 --- a/StructureHelper/Windows/ViewModels/Calculations/Calculators/ForceCalculatorInputDataVM.cs +++ b/StructureHelper/Windows/ViewModels/Calculations/Calculators/ForceCalculatorInputDataVM.cs @@ -15,7 +15,7 @@ namespace StructureHelper.Windows.ViewModels.Calculations.Calculators { public class ForceCalculatorInputDataVM : ViewModelBase { - private ForceInputData inputData; + private IForceCalculatorInputData inputData; SecondOrderViewModel secondOrderViewModel; public double IterationAccuracy @@ -41,7 +41,7 @@ namespace StructureHelper.Windows.ViewModels.Calculations.Calculators public SourceTargetVM PrimitivesViewModel { get; private set; } - public ForceCalculatorInputDataVM(ForceInputData inputData, IEnumerable allowedPrimitives, IEnumerable allowedCombinations) + public ForceCalculatorInputDataVM(IForceCalculatorInputData inputData, IEnumerable allowedPrimitives, IEnumerable allowedCombinations) { this.inputData = inputData; secondOrderViewModel = new SecondOrderViewModel(this.inputData.CompressedMember); diff --git a/StructureHelper/Windows/ViewModels/Calculations/Calculators/ForceCalculatorViewModel.cs b/StructureHelper/Windows/ViewModels/Calculations/Calculators/ForceCalculatorViewModel.cs index 0a4ba85..429b8f0 100644 --- a/StructureHelper/Windows/ViewModels/Calculations/Calculators/ForceCalculatorViewModel.cs +++ b/StructureHelper/Windows/ViewModels/Calculations/Calculators/ForceCalculatorViewModel.cs @@ -16,7 +16,7 @@ namespace StructureHelper.Windows.ViewModels.Calculations.Calculators { public class ForceCalculatorViewModel : OkCancelViewModelBase { - ForceCalculator forcesCalculator; + IForceCalculator forcesCalculator; public string Name { @@ -26,7 +26,10 @@ namespace StructureHelper.Windows.ViewModels.Calculations.Calculators public ForceCalculatorInputDataVM InputData { get; } - public ForceCalculatorViewModel(IEnumerable allowedPrimitives, IEnumerable allowedCombinations, ForceCalculator forcesCalculator) + public ForceCalculatorViewModel( + IEnumerable allowedPrimitives, + IEnumerable allowedCombinations, + IForceCalculator forcesCalculator) { this.forcesCalculator = forcesCalculator; InputData = new ForceCalculatorInputDataVM(this.forcesCalculator.InputData, allowedPrimitives, allowedCombinations); diff --git a/StructureHelper/Windows/ViewModels/NdmCrossSections/PrimitiveViewModelLogic.cs b/StructureHelper/Windows/ViewModels/NdmCrossSections/PrimitiveViewModelLogic.cs index 8ca44b7..989d5b7 100644 --- a/StructureHelper/Windows/ViewModels/NdmCrossSections/PrimitiveViewModelLogic.cs +++ b/StructureHelper/Windows/ViewModels/NdmCrossSections/PrimitiveViewModelLogic.cs @@ -69,7 +69,7 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections INdmPrimitive ndmPrimitive; if (primitiveType == PrimitiveType.Rectangle) { - var primitive = new RectanglePrimitive + var primitive = new RectangleNdmPrimitive { Width = 0.4d, Height = 0.6d @@ -80,7 +80,7 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections } else if (primitiveType == PrimitiveType.Reinforcement) { - var primitive = new RebarPrimitive + var primitive = new RebarNdmPrimitive { Area = 0.0005d }; @@ -89,7 +89,7 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections } else if (primitiveType == PrimitiveType.Point) { - var primitive = new PointPrimitive + var primitive = new PointNdmPrimitive { Area = 0.0005d }; @@ -98,7 +98,7 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections } else if (primitiveType == PrimitiveType.Circle) { - var primitive = new EllipsePrimitive + var primitive = new EllipseNdmPrimitive { Width = 0.5d }; @@ -247,23 +247,23 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections newPrimitive.Name += " copy"; repository.Primitives.Add(newPrimitive); PrimitiveBase primitiveBase; - if (newPrimitive is IRectanglePrimitive) + if (newPrimitive is IRectangleNdmPrimitive) { - primitiveBase = new RectangleViewPrimitive(newPrimitive as IRectanglePrimitive); + primitiveBase = new RectangleViewPrimitive(newPrimitive as IRectangleNdmPrimitive); } - else if (newPrimitive is IEllipsePrimitive) + else if (newPrimitive is IEllipseNdmPrimitive) { - primitiveBase = new CircleViewPrimitive(newPrimitive as IEllipsePrimitive); + primitiveBase = new CircleViewPrimitive(newPrimitive as IEllipseNdmPrimitive); } - else if (newPrimitive is IPointPrimitive) + else if (newPrimitive is IPointNdmPrimitive) { - if (newPrimitive is RebarPrimitive) + if (newPrimitive is RebarNdmPrimitive) { - primitiveBase = new ReinforcementViewPrimitive(newPrimitive as RebarPrimitive); + primitiveBase = new ReinforcementViewPrimitive(newPrimitive as RebarNdmPrimitive); } else { - primitiveBase = new PointViewPrimitive(newPrimitive as IPointPrimitive); + primitiveBase = new PointViewPrimitive(newPrimitive as IPointNdmPrimitive); } } diff --git a/StructureHelper/Windows/ViewModels/PrimitiveProperties/PrimitivePropertiesViewModel.cs b/StructureHelper/Windows/ViewModels/PrimitiveProperties/PrimitivePropertiesViewModel.cs index 080aec7..307eb68 100644 --- a/StructureHelper/Windows/ViewModels/PrimitiveProperties/PrimitivePropertiesViewModel.cs +++ b/StructureHelper/Windows/ViewModels/PrimitiveProperties/PrimitivePropertiesViewModel.cs @@ -305,7 +305,7 @@ namespace StructureHelper.Windows.ViewModels.PrimitiveProperties HostPrimitives = new ObservableCollection(); foreach (var item in sectionRepository.Primitives) { - if (item is RectanglePrimitive || item is EllipsePrimitive) + if (item is RectangleNdmPrimitive || item is EllipseNdmPrimitive) { CheckHost(primitive, item); HostPrimitives.Add(PrimitiveOperations.ConvertNdmPrimitiveToPrimitiveBase(item)); @@ -316,10 +316,10 @@ namespace StructureHelper.Windows.ViewModels.PrimitiveProperties private void CheckHost(PrimitiveBase primitive, INdmPrimitive item) { var ndm = primitive.GetNdmPrimitive(); - if (ndm is RebarPrimitive) + if (ndm is RebarNdmPrimitive) { var host = item as IHasDivisionSize; - var reinforcement = ndm as RebarPrimitive; + var reinforcement = ndm as RebarNdmPrimitive; bool checkWhenPointLocatedInsideOfItsHost = host.IsPointInside(reinforcement.Center.Clone() as IPoint2D); if (checkWhenPointLocatedInsideOfItsHost && reinforcement.HostPrimitive is null) diff --git a/StructureHelperCommon/Infrastructures/Interfaces/IHasCenter2D.cs b/StructureHelperCommon/Infrastructures/Interfaces/IHasCenter2D.cs index 69a6442..1ca3381 100644 --- a/StructureHelperCommon/Infrastructures/Interfaces/IHasCenter2D.cs +++ b/StructureHelperCommon/Infrastructures/Interfaces/IHasCenter2D.cs @@ -16,5 +16,9 @@ namespace StructureHelperCommon.Infrastructures.Interfaces /// 2D point of center /// IPoint2D Center {get;set;} + /// + /// Angle of rotation orbitrary center + /// + double RotationAngle { get; set; } } } diff --git a/StructureHelperCommon/Models/Calculators/Accuracy.cs b/StructureHelperCommon/Models/Calculators/Accuracy.cs index 4b7fadb..b2a6904 100644 --- a/StructureHelperCommon/Models/Calculators/Accuracy.cs +++ b/StructureHelperCommon/Models/Calculators/Accuracy.cs @@ -1,8 +1,25 @@ -namespace StructureHelperCommon.Models.Calculators +using System; + +namespace StructureHelperCommon.Models.Calculators { + /// public class Accuracy : IAccuracy { + /// + public Guid Id { get; } + /// public double IterationAccuracy { get; set; } + /// public int MaxIterationCount { get; set; } + public Accuracy(Guid id) + { + Id = id; + } + + public Accuracy() : this (Guid.NewGuid()) + { + + } + } } diff --git a/StructureHelperCommon/Models/Calculators/FindParameterCalculator.cs b/StructureHelperCommon/Models/Calculators/FindParameterCalculator.cs index bc83347..48593c7 100644 --- a/StructureHelperCommon/Models/Calculators/FindParameterCalculator.cs +++ b/StructureHelperCommon/Models/Calculators/FindParameterCalculator.cs @@ -21,6 +21,8 @@ namespace StructureHelperCommon.Models.Calculators public Action ActionToOutputResults { get; set; } public IShiftTraceLogger? TraceLogger { get; set; } + public Guid Id => throw new NotImplementedException(); + public FindParameterCalculator() { InputData = new FindParameterCalculatorInputData(); diff --git a/StructureHelperCommon/Models/Calculators/IAccuracy.cs b/StructureHelperCommon/Models/Calculators/IAccuracy.cs index 613cc19..d03d238 100644 --- a/StructureHelperCommon/Models/Calculators/IAccuracy.cs +++ b/StructureHelperCommon/Models/Calculators/IAccuracy.cs @@ -1,9 +1,11 @@ -namespace StructureHelperCommon.Models.Calculators +using StructureHelperCommon.Infrastructures.Interfaces; + +namespace StructureHelperCommon.Models.Calculators { /// /// Rate of calculation which based on iteration of finished accuracy /// - public interface IAccuracy + public interface IAccuracy : ISaveable { /// /// Max accuracy of iteration diff --git a/StructureHelperCommon/Models/Calculators/ICalculator.cs b/StructureHelperCommon/Models/Calculators/ICalculator.cs index a1b0482..1805281 100644 --- a/StructureHelperCommon/Models/Calculators/ICalculator.cs +++ b/StructureHelperCommon/Models/Calculators/ICalculator.cs @@ -3,7 +3,7 @@ using System; namespace StructureHelperCommon.Models.Calculators { - public interface ICalculator : ILogic, ICloneable + public interface ICalculator : ILogic, ISaveable, ICloneable { string Name { get; set; } /// diff --git a/StructureHelperCommon/Models/Sections/CompressedMember.cs b/StructureHelperCommon/Models/Sections/CompressedMember.cs index 7a0feae..c40bb50 100644 --- a/StructureHelperCommon/Models/Sections/CompressedMember.cs +++ b/StructureHelperCommon/Models/Sections/CompressedMember.cs @@ -1,4 +1,6 @@ -namespace StructureHelperCommon.Models.Sections +using System; + +namespace StructureHelperCommon.Models.Sections { //Copyright (c) 2023 Redikultsev Evgeny, Ekaterinburg, Russia @@ -9,29 +11,30 @@ { static readonly CompressedMemberUpdateStrategy updateStrategy = new(); /// - public bool Buckling { get; set; } + public Guid Id { get;} /// - public double GeometryLength { get; set; } + public bool Buckling { get; set; } = true; /// - public double LengthFactorX { get; set; } + public double GeometryLength { get; set; } = 3d; /// - public double DiagramFactorX { get; set; } + public double LengthFactorX { get; set; } = 1d; /// - public double LengthFactorY { get; set; } + public double DiagramFactorX { get; set; } = 1d; /// - public double DiagramFactorY { get; set; } - + public double LengthFactorY { get; set; } = 1d; + /// + public double DiagramFactorY { get; set; } = 1d; - public CompressedMember() + public CompressedMember(Guid id) { - Buckling = true; - GeometryLength = 3d; - LengthFactorX = 1d; - DiagramFactorX = 1d; - LengthFactorY = 1d; - DiagramFactorY = 1d; + Id = id; } + public CompressedMember() : this(Guid.NewGuid()) + { + } + + public object Clone() { var newItem = new CompressedMember(); diff --git a/StructureHelperCommon/Models/Sections/ICompressedMember.cs b/StructureHelperCommon/Models/Sections/ICompressedMember.cs index c1761bd..285717c 100644 --- a/StructureHelperCommon/Models/Sections/ICompressedMember.cs +++ b/StructureHelperCommon/Models/Sections/ICompressedMember.cs @@ -1,4 +1,5 @@ -using System; +using StructureHelperCommon.Infrastructures.Interfaces; +using System; namespace StructureHelperCommon.Models.Sections { @@ -9,7 +10,7 @@ namespace StructureHelperCommon.Models.Sections /// /// Interface of properties for compressed strucrue members /// - public interface ICompressedMember : ICloneable + public interface ICompressedMember : ISaveable, ICloneable { /// /// Flag of considering of buckling diff --git a/StructureHelperCommon/Models/Shapes/IRectangleShape.cs b/StructureHelperCommon/Models/Shapes/IRectangleShape.cs index d98dd10..53bfcd6 100644 --- a/StructureHelperCommon/Models/Shapes/IRectangleShape.cs +++ b/StructureHelperCommon/Models/Shapes/IRectangleShape.cs @@ -10,9 +10,5 @@ /// Height of rectangle, m /// double Height { get; set; } - /// - /// Angle of rotating rectangle, rad - /// - double Angle { get; set; } } } diff --git a/StructureHelperCommon/Models/Shapes/Logics/RectangleShapeUpdateStrategy.cs b/StructureHelperCommon/Models/Shapes/Logics/RectangleShapeUpdateStrategy.cs index 8a7d234..73a2726 100644 --- a/StructureHelperCommon/Models/Shapes/Logics/RectangleShapeUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Shapes/Logics/RectangleShapeUpdateStrategy.cs @@ -17,7 +17,6 @@ namespace StructureHelperCommon.Models.Shapes if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Width = sourceObject.Width; targetObject.Height = sourceObject.Height; - targetObject.Angle = sourceObject.Angle; } } } diff --git a/StructureHelperCommon/Models/Shapes/RectangleShape.cs b/StructureHelperCommon/Models/Shapes/RectangleShape.cs index b88026e..d4b3b89 100644 --- a/StructureHelperCommon/Models/Shapes/RectangleShape.cs +++ b/StructureHelperCommon/Models/Shapes/RectangleShape.cs @@ -10,8 +10,6 @@ namespace StructureHelperCommon.Models.Shapes public double Width { get; set; } /// public double Height { get; set; } - /// - public double Angle { get; set; } public RectangleShape(Guid id) { diff --git a/StructureHelperCommon/Models/Soils/AnchorCalculator.cs b/StructureHelperCommon/Models/Soils/AnchorCalculator.cs index fee8d7f..10e7a50 100644 --- a/StructureHelperCommon/Models/Soils/AnchorCalculator.cs +++ b/StructureHelperCommon/Models/Soils/AnchorCalculator.cs @@ -23,6 +23,8 @@ namespace StructureHelperCommon.Models.Soils public Action ActionToOutputResults { get => throw new NotImplementedException(); set => throw new NotImplementedException(); } public IShiftTraceLogger? TraceLogger { get => throw new NotImplementedException(); set => throw new NotImplementedException(); } + public Guid Id => throw new NotImplementedException(); + public AnchorCalculator(SoilAnchor soilAnchor, IAnchorSoilProperties anchorSoilProperties) { Anchor = soilAnchor; diff --git a/StructureHelperLogics/Models/Templates/CrossSections/RCs/CircleGeometryLogic.cs b/StructureHelperLogics/Models/Templates/CrossSections/RCs/CircleGeometryLogic.cs index e2be21a..627bf15 100644 --- a/StructureHelperLogics/Models/Templates/CrossSections/RCs/CircleGeometryLogic.cs +++ b/StructureHelperLogics/Models/Templates/CrossSections/RCs/CircleGeometryLogic.cs @@ -13,7 +13,7 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs public class CircleGeometryLogic : IRCGeometryLogic { ICircleTemplate template; - EllipsePrimitive concreteBlock; + EllipseNdmPrimitive concreteBlock; public IEnumerable HeadMaterials { get; set; } @@ -35,7 +35,7 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs var diameter = template.Shape.Diameter; var concreteMaterial = HeadMaterials.ToList()[0]; var primitives = new List(); - concreteBlock = new EllipsePrimitive() { Width = diameter, Name = "Concrete block"}; + concreteBlock = new EllipseNdmPrimitive() { Width = diameter, Name = "Concrete block"}; concreteBlock.NdmElement.HeadMaterial = concreteMaterial; primitives.Add(concreteBlock); return primitives; @@ -53,7 +53,7 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs var angle = i * dAngle; var x = radius * Math.Sin(angle); var y = radius * Math.Cos(angle); - var point = new RebarPrimitive() + var point = new RebarNdmPrimitive() { Area = barArea, Name = "Left bottom point", diff --git a/StructureHelperLogics/Models/Templates/CrossSections/RCs/RectGeometryLogic.cs b/StructureHelperLogics/Models/Templates/CrossSections/RCs/RectGeometryLogic.cs index fa7a4aa..ff4c4e4 100644 --- a/StructureHelperLogics/Models/Templates/CrossSections/RCs/RectGeometryLogic.cs +++ b/StructureHelperLogics/Models/Templates/CrossSections/RCs/RectGeometryLogic.cs @@ -17,7 +17,7 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs IRectangleBeamTemplate template; IHeadMaterial concrete => HeadMaterials.ToList()[0]; IHeadMaterial reinforcement => HeadMaterials.ToList()[1]; - RectanglePrimitive concreteBlock; + RectangleNdmPrimitive concreteBlock; RectangleShape rect => template.Shape as RectangleShape; double width => rect.Width; @@ -48,7 +48,7 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs private IEnumerable GetConcretePrimitives() { var primitives = new List(); - concreteBlock = new RectanglePrimitive() { Width = width, Height = height, Name = "Concrete block" }; + concreteBlock = new RectangleNdmPrimitive() { Width = width, Height = height, Name = "Concrete block" }; concreteBlock.NdmElement.HeadMaterial = concrete; primitives.Add(concreteBlock); return primitives; @@ -60,7 +60,7 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs double[] ys = new double[] { -height / 2 + gap, height / 2 - gap }; List primitives = new List(); - var point = new RebarPrimitive() + var point = new RebarNdmPrimitive() { Area = area1, Name = "Left bottom rebar", @@ -71,7 +71,7 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs point.Center.X = xs[0]; point.Center.Y = ys[0]; primitives.Add(point); - point = new RebarPrimitive() + point = new RebarNdmPrimitive() { Area = area1, Name = "Right bottom rebar", @@ -81,7 +81,7 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs point.Center.X = xs[1]; point.Center.Y = ys[0]; primitives.Add(point); - point = new RebarPrimitive() + point = new RebarNdmPrimitive() { Area = area2, Name = "Left top rebar", @@ -91,7 +91,7 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs point.Center.X = xs[0]; point.Center.Y = ys[1]; primitives.Add(point); - point = new RebarPrimitive() + point = new RebarNdmPrimitive() { Area = area2, Name = "Right top rebar", @@ -110,14 +110,14 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs double[] ys = new double[] { -height / 2 + gap, height / 2 - gap }; List primitives = new List(); - IPointPrimitive point; + IPointNdmPrimitive point; if (template.WidthCount > 2) { int count = template.WidthCount - 1; double dist = (xs[1] - xs[0]) / count; for (int i = 1; i < count; i++) { - point = new RebarPrimitive() + point = new RebarNdmPrimitive() { Area = area1, Name = $"Bottom rebar {i}", @@ -127,7 +127,7 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs point.Center.X = xs[0] + dist * i; point.Center.Y = ys[0]; primitives.Add(point); - point = new RebarPrimitive() + point = new RebarNdmPrimitive() { Area = area2, Name = $"Top rebar {i}", @@ -145,7 +145,7 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs double dist = (ys[1] - ys[0]) / count; for (int i = 1; i < count; i++) { - point = new RebarPrimitive() + point = new RebarNdmPrimitive() { Area = area1, Name = $"Left point {i}", @@ -155,7 +155,7 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs point.Center.X = xs[0]; point.Center.Y = ys[0] + dist * i; primitives.Add(point); - point = new RebarPrimitive() + point = new RebarNdmPrimitive() { Area = area1, Name = $"Right point {i}", diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs index e2ec72a..80be38f 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs @@ -13,13 +13,13 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces { - internal class CheckForceCalculatorInputData : ICheckInputDataLogic + internal class CheckForceCalculatorInputData : ICheckInputDataLogic { private bool result; private string checkResult; private ICheckEntityLogic checkAccuracyLogic; - public IForceInputData InputData { get; set; } + public IForceCalculatorInputData InputData { get; set; } public string CheckResult => checkResult; diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs index cedb759..2788432 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculator.cs @@ -6,29 +6,35 @@ using StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics; namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces { - public class ForceCalculator : ICalculator, IHasActionByResult + public class ForceCalculator : IForceCalculator { - private IUpdateStrategy updateStrategy; - private ICheckInputDataLogic checkInputDataLogic; + private IUpdateStrategy updateStrategy; + private ICheckInputDataLogic checkInputDataLogic; private IForceCalculatorLogic forceCalculatorLogic; - + /// + public Guid Id { get; } = Guid.NewGuid(); + /// public string Name { get; set; } - public ForceInputData InputData {get;set;} + /// + public IForceCalculatorInputData InputData { get; set; } = new ForceCalculatorInputData(); + /// public Action ActionToOutputResults { get; set; } + /// public IShiftTraceLogger? TraceLogger { get; set; } + /// public IResult Result { get; private set; } - public ForceCalculator(ICheckInputDataLogic checkInputDataLogic, + + public ForceCalculator( + ICheckInputDataLogic checkInputDataLogic, IForceCalculatorLogic forceCalculatorLogic, - IUpdateStrategy updateStrategy + IUpdateStrategy updateStrategy ) { this.checkInputDataLogic = checkInputDataLogic; this.forceCalculatorLogic = forceCalculatorLogic; this.updateStrategy = updateStrategy; - - InputData = new ForceInputData(); } public ForceCalculator() : diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorInputData.cs new file mode 100644 index 0000000..21b7fa1 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorInputData.cs @@ -0,0 +1,38 @@ +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Sections; +using StructureHelperLogics.Models.Calculations.CalculationProperties; +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces +{ + public class ForceCalculatorInputData : IForceCalculatorInputData + { + public Guid Id { get; } + public List LimitStatesList { get; private set; } = new List() { LimitStates.ULS, LimitStates.SLS}; + public List CalcTermsList { get; private set; } = new List() {CalcTerms.ShortTerm, CalcTerms.LongTerm}; + public List ForceActions { get; private set; } = new(); + public List Primitives { get; private set; } = new(); + public ICompressedMember CompressedMember { get; set; } = new CompressedMember() { Buckling = false}; + public IAccuracy Accuracy { get; set; } = new Accuracy() {IterationAccuracy = 0.001d, MaxIterationCount = 1000}; + public List ForceCombinationLists { get; set; } + + public ForceCalculatorInputData(Guid id) + { + Id = id; + } + + public ForceCalculatorInputData() : this (Guid.NewGuid()) + { + + } + + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorInputDataUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorInputDataUpdateStrategy.cs index a20a775..a1a2622 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorInputDataUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorInputDataUpdateStrategy.cs @@ -13,7 +13,7 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces { - public class ForceCalculatorInputDataUpdateStrategy : IUpdateStrategy + public class ForceCalculatorInputDataUpdateStrategy : IUpdateStrategy { private IUpdateStrategy primitivesUpdateStrategy; private IUpdateStrategy forceCombinationUpdateStrategy; @@ -39,7 +39,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces ) { } - public void Update(ForceInputData targetObject, ForceInputData sourceObject) + public void Update(IForceCalculatorInputData targetObject, IForceCalculatorInputData sourceObject) { CheckObject.IsNull(targetObject, sourceObject, "Force calculator input data"); if (ReferenceEquals(targetObject, sourceObject)) { return; } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorLogic.cs index 85b0499..fdcbe9b 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceCalculatorLogic.cs @@ -18,7 +18,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces private IProcessorLogic eccentricityLogic; private ForceTupleBucklingLogic bucklingLogic; private ITriangulatePrimitiveLogic triangulateLogic; - public IForceInputData InputData { get; set; } + public IForceCalculatorInputData InputData { get; set; } public IShiftTraceLogger? TraceLogger { get; set; } public Action ActionToOutputResults { get; set; } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceInputData.cs deleted file mode 100644 index 30472b5..0000000 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceInputData.cs +++ /dev/null @@ -1,52 +0,0 @@ -using StructureHelperCommon.Infrastructures.Enums; -using StructureHelperCommon.Infrastructures.Interfaces; -using StructureHelperCommon.Models.Calculators; -using StructureHelperCommon.Models.Forces; -using StructureHelperCommon.Models.Sections; -using StructureHelperLogics.Models.Calculations.CalculationProperties; -using StructureHelperLogics.NdmCalculations.Primitives; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces -{ - public class ForceInputData : IForceInputData - { - public List LimitStatesList { get; private set; } - public List CalcTermsList { get; private set; } - public List ForceActions { get; private set; } - public List Primitives { get; private set; } - public ICompressedMember CompressedMember { get; set; } - public IAccuracy Accuracy { get; set; } - public List ForceCombinationLists { get; set; } - - public ForceInputData() - { - ForceActions = new List(); - ForceCombinationLists = new List(); - Primitives = new List(); - CompressedMember = new CompressedMember() - { - Buckling = false - }; - Accuracy = new Accuracy() - { - IterationAccuracy = 0.001d, - MaxIterationCount = 1000 - }; - LimitStatesList = new List() - { - LimitStates.ULS, - LimitStates.SLS - }; - CalcTermsList = new List() - { - CalcTerms.ShortTerm, - CalcTerms.LongTerm - }; - } - } -} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs index 3d3dfc8..0940441 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleCalculator.cs @@ -28,6 +28,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces public Action ActionToOutputResults { get; set; } public IShiftTraceLogger? TraceLogger { get; set; } + public Guid Id => throw new NotImplementedException(); + public ForceTupleCalculator(ICheckInputDataLogic checkInputDataLogic, IForceTupleCalcLogic calcLogic) { this.checkInputDataLogic = checkInputDataLogic; diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceCalculator.cs new file mode 100644 index 0000000..0c428fd --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceCalculator.cs @@ -0,0 +1,15 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Calculators; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces +{ + public interface IForceCalculator : ICalculator, IHasActionByResult + { + IForceCalculatorInputData InputData { get; set; } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceCalculatorInputData.cs similarity index 85% rename from StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceInputData.cs rename to StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceCalculatorInputData.cs index f77c3ea..8524103 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceCalculatorInputData.cs @@ -7,7 +7,7 @@ using StructureHelperLogics.NdmCalculations.Primitives; namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces { - public interface IForceInputData : IInputData, IHasPrimitives, IHasForceCombinations + public interface IForceCalculatorInputData : IInputData, ISaveable, IHasPrimitives, IHasForceCombinations { IAccuracy Accuracy { get; set; } List CalcTermsList { get; } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceCalculatorLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceCalculatorLogic.cs index 72fae4f..e244ba1 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceCalculatorLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/IForceCalculatorLogic.cs @@ -10,7 +10,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces { public interface IForceCalculatorLogic : ILogic, IHasActionByResult { - IForceInputData InputData { get; set; } + IForceCalculatorInputData InputData { get; set; } ForcesResults GetForcesResults(); } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveCalculator.cs index 00ac052..4c24953 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/LimitCurveCalculator.cs @@ -22,6 +22,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces public Action ActionToOutputResults { get; set; } public IShiftTraceLogger? TraceLogger { get; set; } + public Guid Id => throw new NotImplementedException(); + public LimitCurveCalculator(ILimitCurveLogic limitCurveLogic) { this.limitCurveLogic = limitCurveLogic; diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceCalculatorUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceCalculatorUpdateStrategy.cs index 126bad8..ce29e46 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceCalculatorUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceCalculatorUpdateStrategy.cs @@ -5,20 +5,21 @@ using StructureHelperCommon.Services; namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics { - public class ForceCalculatorUpdateStrategy : IUpdateStrategy + public class ForceCalculatorUpdateStrategy : IUpdateStrategy { - private readonly IUpdateStrategy inputDataUpdateStrategy; - public ForceCalculatorUpdateStrategy(IUpdateStrategy inputDataUpdateStrategy) + private readonly IUpdateStrategy inputDataUpdateStrategy; + public ForceCalculatorUpdateStrategy(IUpdateStrategy inputDataUpdateStrategy) { this.inputDataUpdateStrategy = inputDataUpdateStrategy; } public ForceCalculatorUpdateStrategy() : this(new ForceCalculatorInputDataUpdateStrategy()) { } - public void Update(ForceCalculator targetObject, ForceCalculator sourceObject) + public void Update(IForceCalculator targetObject, IForceCalculator sourceObject) { - CheckObject.IsNull(targetObject, sourceObject); + CheckObject.IsNull(targetObject); + CheckObject.IsNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Name = sourceObject.Name; - targetObject.InputData ??= new ForceInputData(); + targetObject.InputData ??= new ForceCalculatorInputData(); inputDataUpdateStrategy.Update(targetObject.InputData, sourceObject.InputData); } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Geometry/GeometryCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/Geometry/GeometryCalculator.cs index 7e34ca8..875e1ed 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/Geometry/GeometryCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/Geometry/GeometryCalculator.cs @@ -17,6 +17,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Geometry public Action ActionToOutputResults { get => throw new NotImplementedException(); set => throw new NotImplementedException(); } public IShiftTraceLogger? TraceLogger { get => throw new NotImplementedException(); set => throw new NotImplementedException(); } + public Guid Id => throw new NotImplementedException(); + public GeometryCalculator(IEnumerable ndms, IStrainMatrix strainMatrix) { parametersLogic = new TextParametersLogic(ndms, strainMatrix); diff --git a/StructureHelperLogics/NdmCalculations/Analyses/RC/InputDataFactory.cs b/StructureHelperLogics/NdmCalculations/Analyses/RC/InputDataFactory.cs index 9efe1bb..7544676 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/RC/InputDataFactory.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/RC/InputDataFactory.cs @@ -17,7 +17,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.RC public static class InputDataFactory { private static IStressLogic stressLogic => new StressLogic(); - public static IAnchorageInputData GetInputData(RebarPrimitive ndmPrimitive, IStrainMatrix strainMatrix, LimitStates limitState, CalcTerms calcTerm, double lappedCountRate) + public static IAnchorageInputData GetInputData(RebarNdmPrimitive ndmPrimitive, IStrainMatrix strainMatrix, LimitStates limitState, CalcTerms calcTerm, double lappedCountRate) { var inputData = new AnchorageInputData(); inputData.ConcreteStrength = GetConcreteStrength(limitState, calcTerm, ndmPrimitive); @@ -47,7 +47,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.RC return inputData; } - private static double GetConcreteStrength(LimitStates limitState, CalcTerms calcTerm, RebarPrimitive primitive) + private static double GetConcreteStrength(LimitStates limitState, CalcTerms calcTerm, RebarNdmPrimitive primitive) { if (primitive.HostPrimitive is not null) { @@ -66,7 +66,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.RC throw new StructureHelperException(ErrorStrings.DataIsInCorrect + ": host material is incorrect or null"); } - private static double GetReinforcementStrength(LimitStates limitState, CalcTerms calcTerm, RebarPrimitive primitive) + private static double GetReinforcementStrength(LimitStates limitState, CalcTerms calcTerm, RebarNdmPrimitive primitive) { if (primitive.NdmElement.HeadMaterial.HelperMaterial is IReinforcementLibMaterial) { diff --git a/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs b/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs index 67f1fdd..e9de060 100644 --- a/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Buckling/ConcreteBucklingCalculator.cs @@ -35,6 +35,8 @@ namespace StructureHelperLogics.NdmCalculations.Buckling public Action ActionToOutputResults { get; set; } public IShiftTraceLogger? TraceLogger { get; set; } + public Guid Id => throw new NotImplementedException(); + private (double EtaAlongX, double EtaAlongY) GetBucklingCoefficients() { var (DX, DY) = GetStiffness(); diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs index a117853..45ee725 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculator.cs @@ -25,11 +25,15 @@ namespace StructureHelperLogics.NdmCalculations.Cracking private IUpdateStrategy updateStrategy; private ICheckInputDataLogic checkInputDataLogic; + public Guid Id { get; } = Guid.NewGuid(); + public string Name { get; set; } public ICrackCalculatorInputData InputData { get; set; } public IResult Result => result; public IShiftTraceLogger? TraceLogger { get; set; } + + public CrackCalculator(ICheckInputDataLogic checkInputDataLogic, IUpdateStrategy updateStrategy, IShiftTraceLogger traceLogger diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorInputData.cs index 7569192..38482cc 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorInputData.cs @@ -12,16 +12,16 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { public class CrackCalculatorInputData : ICrackCalculatorInputData { + public Guid Id { get; } = new(); /// - public List Primitives { get; private set; } + public List Primitives { get; private set; } = new(); /// - public List ForceActions { get; private set; } - public IUserCrackInputData UserCrackInputData { get; set; } - public CrackCalculatorInputData() + public List ForceActions { get; private set; } = new(); + public IUserCrackInputData UserCrackInputData { get; set; } = GetNewUserData(); + + private static UserCrackInputData GetNewUserData() { - Primitives = new(); - ForceActions = new(); - UserCrackInputData = new UserCrackInputData() + return new UserCrackInputData() { SetSofteningFactor = true, SofteningFactor = 1d, diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs index 27a39e9..6817e23 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackCalculatorUpdateStrategy.cs @@ -19,7 +19,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public CrackCalculatorUpdateStrategy() : this(new CrackInputDataUpdateStrategy()) { } public void Update(ICrackCalculator targetObject, ICrackCalculator sourceObject) { - CheckObject.CompareTypes(targetObject, sourceObject); + CheckObject.IsNull(targetObject); + CheckObject.IsNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Name = sourceObject.Name; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceBynarySearchCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackForceBynarySearchCalculator.cs index 5ac3b05..53ce496 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceBynarySearchCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackForceBynarySearchCalculator.cs @@ -30,6 +30,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public IShiftTraceLogger? TraceLogger { get; set; } + public Guid Id => throw new NotImplementedException(); + public CrackForceBynarySearchCalculator( IIsSectionCrackedByFactorLogic crackedByFactorLogic, ICheckInputDataLogic checkInputDataLogic diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceSteppedSearchCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackForceSteppedSearchCalculator.cs index 6d26475..2626b3f 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceSteppedSearchCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackForceSteppedSearchCalculator.cs @@ -17,6 +17,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public IShiftTraceLogger? TraceLogger { get; set; } + public Guid Id => throw new NotImplementedException(); + public object Clone() { throw new NotImplementedException(); diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs index 27d5571..ad48d51 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackInputDataUpdateStrategy.cs @@ -22,7 +22,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking } public void Update(ICrackCalculatorInputData targetObject, ICrackCalculatorInputData sourceObject) { - CheckObject.CompareTypes(targetObject, sourceObject); + CheckObject.IsNull(targetObject); + CheckObject.IsNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.ForceActions.Clear(); targetObject.ForceActions.AddRange(sourceObject.ForceActions); diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackedSectionTriangulationLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackedSectionTriangulationLogic.cs index cb69a93..d29f9da 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackedSectionTriangulationLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackedSectionTriangulationLogic.cs @@ -70,14 +70,14 @@ namespace StructureHelperLogics.NdmCalculations.Cracking } /// - public List GetRebarPrimitives() + public List GetRebarPrimitives() { TraceLogger?.AddMessage(LoggerStrings.LogicType(this), TraceLogStatuses.Debug); TraceLogger?.AddMessage(ndmPrimitiveCountMessage, TraceLogStatuses.Debug); - List rebarPrimitives = new(); + List rebarPrimitives = new(); foreach (var item in NdmPrimitives) { - if (item is IRebarPrimitive rebar) + if (item is IRebarNdmPrimitive rebar) { TraceLogger?.AddMessage($"Primitive {rebar.Name} is rebar primitive", TraceLogStatuses.Service); rebarPrimitives.Add(rebar); diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ICrackCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/ICrackCalculatorInputData.cs index f1de0e1..70d6ff7 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/ICrackCalculatorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/ICrackCalculatorInputData.cs @@ -5,7 +5,7 @@ using StructureHelperLogics.NdmCalculations.Primitives; namespace StructureHelperLogics.NdmCalculations.Cracking { - public interface ICrackCalculatorInputData : IInputData, IHasPrimitives, IHasForceCombinations + public interface ICrackCalculatorInputData : IInputData, IHasPrimitives, IHasForceCombinations, ISaveable { List ForceActions { get; } List Primitives { get; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ICrackedSectionTriangulationLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/ICrackedSectionTriangulationLogic.cs index 7ad87ed..70592c4 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/ICrackedSectionTriangulationLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/ICrackedSectionTriangulationLogic.cs @@ -37,6 +37,6 @@ namespace StructureHelperLogics.NdmCalculations.Cracking /// Return collection of primitives which contain only rebars /// /// - List GetRebarPrimitives(); + List GetRebarPrimitives(); } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/IRebarCalulatorsFactory.cs b/StructureHelperLogics/NdmCalculations/Cracking/IRebarCalulatorsFactory.cs index b3965a4..2d07259 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/IRebarCalulatorsFactory.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/IRebarCalulatorsFactory.cs @@ -7,7 +7,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { TupleCrackInputData InputData { get; set; } double LongLength { get; set; } - IEnumerable Rebars { get; set; } + IEnumerable Rebars { get; set; } double ShortLength { get; set; } List GetCalculators(); diff --git a/StructureHelperLogics/NdmCalculations/Cracking/IRebarCrackCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/IRebarCrackCalculatorInputData.cs index d375f62..c3c8e68 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/IRebarCrackCalculatorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/IRebarCrackCalculatorInputData.cs @@ -19,7 +19,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking /// /// Rebar primitive /// - IRebarPrimitive RebarPrimitive { get; set; } + IRebarNdmPrimitive RebarPrimitive { get; set; } /// /// User settings for crack calculations /// diff --git a/StructureHelperLogics/NdmCalculations/Cracking/IRebarCrackInputDataFactory.cs b/StructureHelperLogics/NdmCalculations/Cracking/IRebarCrackInputDataFactory.cs index 4b0045a..50363af 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/IRebarCrackInputDataFactory.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/IRebarCrackInputDataFactory.cs @@ -4,7 +4,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { public interface IRebarCrackInputDataFactory { - IRebarPrimitive Rebar { get; set; } + IRebarNdmPrimitive Rebar { get; set; } TupleCrackInputData InputData { get; set; } double LongLength { get; set; } double ShortLength { get; set; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/IRebarStressCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/IRebarStressCalculatorInputData.cs index e8947ad..3793237 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/IRebarStressCalculatorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/IRebarStressCalculatorInputData.cs @@ -26,6 +26,6 @@ namespace StructureHelperLogics.NdmCalculations.Cracking /// /// Rebar which stress and strain will be obtained for /// - IRebarPrimitive RebarPrimitive { get; set; } + IRebarNdmPrimitive RebarPrimitive { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/IRebarStressResultLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/IRebarStressResultLogic.cs index e293550..0bdd002 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/IRebarStressResultLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/IRebarStressResultLogic.cs @@ -6,7 +6,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public interface IRebarStressResultLogic : ILogic { IRebarCrackInputData RebarCrackInputData { get; set; } - IRebarPrimitive RebarPrimitive { get; set; } + IRebarNdmPrimitive RebarPrimitive { get; set; } IRebarStressResult GetRebarStressResult(); } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/ITupleRebarsCrackSolver.cs b/StructureHelperLogics/NdmCalculations/Cracking/ITupleRebarsCrackSolver.cs index e8aac70..c33819b 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/ITupleRebarsCrackSolver.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/ITupleRebarsCrackSolver.cs @@ -9,7 +9,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking TupleCrackInputData InputData { get; set; } bool IsResultValid { get; } double LongLength { get; set; } - IEnumerable Rebars { get; set; } + IEnumerable Rebars { get; set; } List Result { get; } double ShortLength { get; set; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/IUserCrackInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/IUserCrackInputData.cs index d12a077..cd4e796 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/IUserCrackInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/IUserCrackInputData.cs @@ -1,8 +1,9 @@ -using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Calculators; namespace StructureHelperLogics.NdmCalculations.Cracking { - public interface IUserCrackInputData : IInputData + public interface IUserCrackInputData : IInputData, ISaveable { double LengthBetweenCracks { get; set; } bool SetLengthBetweenCracks { get; set; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarCalulatorsFactory.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarCalulatorsFactory.cs index 826ee86..522c972 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarCalulatorsFactory.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarCalulatorsFactory.cs @@ -12,7 +12,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { private IRebarCrackInputDataFactory inputFactory; - public IEnumerable Rebars { get; set; } + public IEnumerable Rebars { get; set; } public TupleCrackInputData InputData { get; set; } public double LongLength { get; set; } public double ShortLength { get; set; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculator.cs index 69ee50f..22a2621 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculator.cs @@ -22,6 +22,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public Action ActionToOutputResults { get; set; } public IShiftTraceLogger? TraceLogger { get; set; } + public Guid Id => throw new NotImplementedException(); + public RebarCrackCalculator(ICheckInputDataLogic checkInputDataLogic, ICrackWidthCalculationLogic crackWidthCalculationLogic, IShiftTraceLogger? traceLogger) diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculatorInputData.cs index 2f59114..2d59e32 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculatorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackCalculatorInputData.cs @@ -19,7 +19,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking /// public IRebarCrackInputData? ShortRebarData { get; set; } /// - public IRebarPrimitive RebarPrimitive { get; set; } + public IRebarNdmPrimitive RebarPrimitive { get; set; } /// public IUserCrackInputData? UserCrackInputData { get; set; } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputDataFactory.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputDataFactory.cs index 14e0c65..d009fe6 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputDataFactory.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputDataFactory.cs @@ -31,7 +31,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking } - public IRebarPrimitive Rebar { get; set; } + public IRebarNdmPrimitive Rebar { get; set; } public TupleCrackInputData InputData { get; set; } public double LongLength { get; set; } public double ShortLength { get; set; } @@ -41,9 +41,9 @@ namespace StructureHelperLogics.NdmCalculations.Cracking IEnumerable crackableNdmsLoc = null; IEnumerable crackedNdmsLoc = null; INdm concreteNdmUnderRebar; - RebarPrimitive rebarCopy = null; + RebarNdmPrimitive rebarCopy = null; - rebarCopy = Rebar.Clone() as RebarPrimitive; + rebarCopy = Rebar.Clone() as RebarNdmPrimitive; rebarCopy.NdmElement.HeadMaterial = rebarCopy.NdmElement.HeadMaterial.Clone() as IHeadMaterial; triangulationLogicLoc = new CrackedSectionTriangulationLogic(InputData.Primitives); crackableNdmsLoc = triangulationLogicLoc.GetNdmCollection(); diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackResult.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackResult.cs index 1894c13..46db47d 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackResult.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackResult.cs @@ -20,7 +20,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking /// /// Specific rebar primitive /// - public IRebarPrimitive RebarPrimitive { get; set; } + public IRebarNdmPrimitive RebarPrimitive { get; set; } /// /// Result of calculation of crack for long term /// diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs index 0614ccc..e071b84 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs @@ -28,6 +28,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public IShiftTraceLogger? TraceLogger { get; set; } + public Guid Id => throw new NotImplementedException(); public RebarStressCalculator(IStressLogic stressLogic) { diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculatorInputData.cs index fee7be2..cc3cfc3 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculatorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculatorInputData.cs @@ -17,6 +17,6 @@ namespace StructureHelperLogics.NdmCalculations.Cracking /// public IEnumerable NdmCollection { get; set; } /// - public IRebarPrimitive RebarPrimitive { get; set; } + public IRebarNdmPrimitive RebarPrimitive { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResultLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResultLogic.cs index f433f4a..d09ae67 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResultLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressResultLogic.cs @@ -15,7 +15,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public class RebarStressResultLogic : IRebarStressResultLogic { private IRebarStressCalculator rebarStressCalculator; - public IRebarPrimitive RebarPrimitive { get; set; } + public IRebarNdmPrimitive RebarPrimitive { get; set; } public IRebarCrackInputData RebarCrackInputData { get; set; } public IShiftTraceLogger? TraceLogger { get; set; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/SofteningLogics/RebarStressSofteningLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/SofteningLogics/RebarStressSofteningLogic.cs index 60370af..f06be3f 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/SofteningLogics/RebarStressSofteningLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/SofteningLogics/RebarStressSofteningLogic.cs @@ -37,7 +37,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking private double rebarActualStress; private double softeningFactor; private double minValueOfFactor = 0.2d; - private IRebarPrimitive rebarPrimitive; + private IRebarNdmPrimitive rebarPrimitive; private IRebarCrackInputData inputData; public double MinValueOfFactor @@ -48,7 +48,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking IsResultActual = false; } } - public IRebarPrimitive RebarPrimitive + public IRebarNdmPrimitive RebarPrimitive { get => rebarPrimitive; set { diff --git a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs index a4d94d8..2c30fec 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs @@ -26,7 +26,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking private TupleCrackResult result; private ICrackedSectionTriangulationLogic triangulationLogic; private ITupleRebarsCrackSolver solver; - private List? rebarPrimitives; + private List? rebarPrimitives; private IEnumerable crackableNdms; private IEnumerable crackedNdms; private IEnumerable elasticNdms; @@ -43,6 +43,8 @@ namespace StructureHelperLogics.NdmCalculations.Cracking public IShiftTraceLogger? TraceLogger { get; set; } + public Guid Id => throw new NotImplementedException(); + public TupleCrackCalculator(ICheckInputDataLogic checkInputDataLogic, ILengthBetweenCracksLogic lengthLogic, ICrackedSectionTriangulationLogic triangulationLogic, ITupleRebarsCrackSolver solver) { diff --git a/StructureHelperLogics/NdmCalculations/Cracking/TupleRebarsCrackSolver.cs b/StructureHelperLogics/NdmCalculations/Cracking/TupleRebarsCrackSolver.cs index 53d3c35..8918123 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/TupleRebarsCrackSolver.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/TupleRebarsCrackSolver.cs @@ -14,7 +14,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { private IRebarCalulatorsFactory calculatorsFactory; - public IEnumerable Rebars { get; set; } + public IEnumerable Rebars { get; set; } public TupleCrackInputData InputData { get; set; } public double LongLength { get; set; } public double ShortLength { get; set; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputData.cs b/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputData.cs index c9d31bd..597d936 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputData.cs @@ -12,6 +12,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking /// public class UserCrackInputData : IUserCrackInputData { + public Guid Id { get; } = new(); /// /// Flag of assigning of user value of softening factor /// @@ -36,5 +37,6 @@ namespace StructureHelperLogics.NdmCalculations.Cracking /// Ultimate short-term crack width, m /// public double UltimateShortCrackWidth { get; set; } + } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputDataUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputDataUpdateStrategy.cs index 8d2714b..6f62c32 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputDataUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/UserCrackInputDataUpdateStrategy.cs @@ -12,8 +12,9 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { public void Update(IUserCrackInputData targetObject, IUserCrackInputData sourceObject) { + CheckObject.IsNull(targetObject); + CheckObject.IsNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } - CheckObject.CompareTypes(targetObject, sourceObject); targetObject.SetSofteningFactor = sourceObject.SetSofteningFactor; targetObject.SofteningFactor = sourceObject.SofteningFactor; diff --git a/StructureHelperLogics/NdmCalculations/Primitives/EllipsePrimitive.cs b/StructureHelperLogics/NdmCalculations/Primitives/EllipseNdmPrimitive.cs similarity index 93% rename from StructureHelperLogics/NdmCalculations/Primitives/EllipsePrimitive.cs rename to StructureHelperLogics/NdmCalculations/Primitives/EllipseNdmPrimitive.cs index 952ddb9..f85cac5 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/EllipsePrimitive.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/EllipseNdmPrimitive.cs @@ -9,7 +9,7 @@ using StructureHelperLogics.NdmCalculations.Triangulations; namespace StructureHelperLogics.NdmCalculations.Primitives { - public class EllipsePrimitive : IEllipsePrimitive + public class EllipseNdmPrimitive : IEllipseNdmPrimitive { private static readonly EllipsePrimitiveUpdateStrategy updateStrategy = new(); private readonly RectangleShape rectangleShape = new(); @@ -45,19 +45,19 @@ namespace StructureHelperLogics.NdmCalculations.Primitives public IDivisionSize DivisionSize { get; } = new DivisionSize(); /// public IShape Shape => rectangleShape; + /// + public double RotationAngle { get; set; } - public double Angle { get; set; } - - public EllipsePrimitive(Guid id) + public EllipseNdmPrimitive(Guid id) { Id = id; Name = "New Circle"; } - public EllipsePrimitive() : this (Guid.NewGuid()) {} + public EllipseNdmPrimitive() : this (Guid.NewGuid()) {} /// public object Clone() { - var primitive = new EllipsePrimitive(); + var primitive = new EllipseNdmPrimitive(); updateStrategy.Update(primitive, this); return primitive; } diff --git a/StructureHelperLogics/NdmCalculations/Primitives/IEllipsePrimitive.cs b/StructureHelperLogics/NdmCalculations/Primitives/IEllipseNdmPrimitive.cs similarity index 72% rename from StructureHelperLogics/NdmCalculations/Primitives/IEllipsePrimitive.cs rename to StructureHelperLogics/NdmCalculations/Primitives/IEllipseNdmPrimitive.cs index 38a127f..c645092 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/IEllipsePrimitive.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/IEllipseNdmPrimitive.cs @@ -7,7 +7,7 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Primitives { - public interface IEllipsePrimitive : INdmPrimitive, IHasDivisionSize, IRectangleShape + public interface IEllipseNdmPrimitive : INdmPrimitive, IHasDivisionSize, IRectangleShape { diff --git a/StructureHelperLogics/NdmCalculations/Primitives/IPointPrimitive.cs b/StructureHelperLogics/NdmCalculations/Primitives/IPointNdmPrimitive.cs similarity index 83% rename from StructureHelperLogics/NdmCalculations/Primitives/IPointPrimitive.cs rename to StructureHelperLogics/NdmCalculations/Primitives/IPointNdmPrimitive.cs index 303b662..37c15c5 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/IPointPrimitive.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/IPointNdmPrimitive.cs @@ -11,7 +11,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives /// /// Geometry primitive of point /// - public interface IPointPrimitive : INdmPrimitive, IPointShape + public interface IPointNdmPrimitive : INdmPrimitive, IPointShape { } } diff --git a/StructureHelperLogics/NdmCalculations/Primitives/IRebarPrimitive.cs b/StructureHelperLogics/NdmCalculations/Primitives/IRebarNdmPrimitive.cs similarity index 83% rename from StructureHelperLogics/NdmCalculations/Primitives/IRebarPrimitive.cs rename to StructureHelperLogics/NdmCalculations/Primitives/IRebarNdmPrimitive.cs index 0a5628c..b0b4974 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/IRebarPrimitive.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/IRebarNdmPrimitive.cs @@ -6,7 +6,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives /// /// Geometry primitive of rebar (bar of reinforcement) /// - public interface IRebarPrimitive : IPointPrimitive, IHasHostPrimitive + public interface IRebarNdmPrimitive : IPointNdmPrimitive, IHasHostPrimitive { Ndm GetConcreteNdm(ITriangulationOptions triangulationOptions); RebarNdm GetRebarNdm(ITriangulationOptions triangulationOptions); diff --git a/StructureHelperLogics/NdmCalculations/Primitives/IRectanglePrimitive.cs b/StructureHelperLogics/NdmCalculations/Primitives/IRectangleNdmPrimitive.cs similarity index 71% rename from StructureHelperLogics/NdmCalculations/Primitives/IRectanglePrimitive.cs rename to StructureHelperLogics/NdmCalculations/Primitives/IRectangleNdmPrimitive.cs index 41cb0ff..5c04988 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/IRectanglePrimitive.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/IRectangleNdmPrimitive.cs @@ -7,7 +7,7 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Primitives { - public interface IRectanglePrimitive : INdmPrimitive, IHasDivisionSize, IRectangleShape + public interface IRectangleNdmPrimitive : INdmPrimitive, IHasDivisionSize, IRectangleShape { } } diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/BaseUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/BaseUpdateStrategy.cs index 9f28b7f..7e13611 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/BaseUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/BaseUpdateStrategy.cs @@ -29,6 +29,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives } targetObject.NdmElement.Triangulate = sourceObject.NdmElement.Triangulate; point2DUpdateStrategy.Update(targetObject.Center, sourceObject.Center); + targetObject.RotationAngle = sourceObject.RotationAngle; visualPropsUpdateStrategy.Update(targetObject.VisualProperty, sourceObject.VisualProperty); tupleUpdateStrategy.Update(targetObject.NdmElement.UsersPrestrain, sourceObject.NdmElement.UsersPrestrain); } diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckPrimitiveCollectionLogic.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckPrimitiveCollectionLogic.cs index bbc42f0..228a65a 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckPrimitiveCollectionLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckPrimitiveCollectionLogic.cs @@ -57,7 +57,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics { foreach (var primitive in HasPrimitives.Primitives) { - if (primitive is IRebarPrimitive rebar) + if (primitive is IRebarNdmPrimitive rebar) { CheckRebar(rebar); } @@ -65,7 +65,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics } } - private void CheckRebar(IRebarPrimitive rebar) + private void CheckRebar(IRebarNdmPrimitive rebar) { if (checkRebarPrimitiveLogic is null) { diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckRebarPrimitiveLogic.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckRebarPrimitiveLogic.cs index a164f65..66a53b3 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckRebarPrimitiveLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckRebarPrimitiveLogic.cs @@ -14,7 +14,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics private string checkResult; private bool result; - public IRebarPrimitive RebarPrimitive { get; set; } + public IRebarNdmPrimitive RebarPrimitive { get; set; } public string CheckResult => checkResult; diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/EllipsePrimitiveUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/EllipsePrimitiveUpdateStrategy.cs index 2b13567..1ebdf29 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/EllipsePrimitiveUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/EllipsePrimitiveUpdateStrategy.cs @@ -5,7 +5,7 @@ using StructureHelperCommon.Services; namespace StructureHelperLogics.NdmCalculations.Primitives { - public class EllipsePrimitiveUpdateStrategy : IUpdateStrategy + public class EllipsePrimitiveUpdateStrategy : IUpdateStrategy { private IUpdateStrategy basePrimitiveUpdateStrategy; private IUpdateStrategy divisionPropsUpdateStrategy; @@ -26,7 +26,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives { } - public void Update(IEllipsePrimitive targetObject, IEllipsePrimitive sourceObject) + public void Update(IEllipseNdmPrimitive targetObject, IEllipseNdmPrimitive sourceObject) { CheckObject.IsNull(sourceObject, "source object"); CheckObject.IsNull(targetObject, "target object"); diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/ICheckRebarPrimitiveLogic.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/ICheckRebarPrimitiveLogic.cs index 1dfbf4a..7389b20 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/ICheckRebarPrimitiveLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/ICheckRebarPrimitiveLogic.cs @@ -9,6 +9,6 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics { public interface ICheckRebarPrimitiveLogic : ICheckLogic { - IRebarPrimitive RebarPrimitive { get; set; } + IRebarNdmPrimitive RebarPrimitive { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmPrimitiveUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmPrimitiveUpdateStrategy.cs index 1c840b8..beef1e6 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmPrimitiveUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmPrimitiveUpdateStrategy.cs @@ -11,21 +11,21 @@ namespace StructureHelperLogics.NdmCalculations.Primitives { if (ReferenceEquals(targetObject, sourceObject)) { return; } CheckObject.CompareTypes(targetObject, sourceObject); - if (targetObject is PointPrimitive point) + if (targetObject is PointNdmPrimitive point) { - new PointUpdateStrategy().Update(point, (PointPrimitive)sourceObject); + new PointPrimitiveUpdateStrategy().Update(point, (PointNdmPrimitive)sourceObject); } - else if (targetObject is RebarPrimitive rebar) + else if (targetObject is RebarNdmPrimitive rebar) { - new RebarUpdateStrategy().Update(rebar, (RebarPrimitive)sourceObject); + new RebarNdmPrimitiveUpdateStrategy().Update(rebar, (RebarNdmPrimitive)sourceObject); } - else if (targetObject is RectanglePrimitive rectangle) + else if (targetObject is RectangleNdmPrimitive rectangle) { - new RectanglePrimitiveUpdateStrategy().Update(rectangle, (RectanglePrimitive)sourceObject); + new RectanglePrimitiveUpdateStrategy().Update(rectangle, (RectangleNdmPrimitive)sourceObject); } - else if (targetObject is EllipsePrimitive circle) + else if (targetObject is EllipseNdmPrimitive circle) { - new EllipsePrimitiveUpdateStrategy().Update(circle, (EllipsePrimitive)sourceObject); + new EllipsePrimitiveUpdateStrategy().Update(circle, (EllipseNdmPrimitive)sourceObject); } else { diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/PointUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/PointPrimitiveUpdateStrategy.cs similarity index 77% rename from StructureHelperLogics/NdmCalculations/Primitives/Logics/PointUpdateStrategy.cs rename to StructureHelperLogics/NdmCalculations/Primitives/Logics/PointPrimitiveUpdateStrategy.cs index b51c1b1..24a24ea 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/PointUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/PointPrimitiveUpdateStrategy.cs @@ -8,10 +8,10 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Primitives { - internal class PointUpdateStrategy : IUpdateStrategy + public class PointPrimitiveUpdateStrategy : IUpdateStrategy { static readonly BaseUpdateStrategy basePrimitiveUpdateStrategy = new(); - public void Update(PointPrimitive targetObject, PointPrimitive sourceObject) + public void Update(IPointNdmPrimitive targetObject, IPointNdmPrimitive sourceObject) { if (ReferenceEquals(targetObject, sourceObject)) { return; } basePrimitiveUpdateStrategy.Update(targetObject, sourceObject); diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/RebarUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/RebarNdmPrimitiveUpdateStrategy.cs similarity index 72% rename from StructureHelperLogics/NdmCalculations/Primitives/Logics/RebarUpdateStrategy.cs rename to StructureHelperLogics/NdmCalculations/Primitives/Logics/RebarNdmPrimitiveUpdateStrategy.cs index 0d26137..2c70aec 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/RebarUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/RebarNdmPrimitiveUpdateStrategy.cs @@ -7,12 +7,13 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Primitives { - internal class RebarUpdateStrategy : IUpdateStrategy + public class RebarNdmPrimitiveUpdateStrategy : IUpdateStrategy { static readonly BaseUpdateStrategy basePrimitiveUpdateStrategy = new(); - public void Update(RebarPrimitive targetObject, RebarPrimitive sourceObject) + public void Update(IRebarNdmPrimitive targetObject, IRebarNdmPrimitive sourceObject) { if (ReferenceEquals(targetObject, sourceObject)) { return; } + if (sourceObject.HostPrimitive is not null) basePrimitiveUpdateStrategy.Update(targetObject, sourceObject); targetObject.Area = sourceObject.Area; targetObject.HostPrimitive = sourceObject.HostPrimitive; diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/RectanglePrimitiveUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/RectanglePrimitiveUpdateStrategy.cs index 3c43e59..90a15e5 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/RectanglePrimitiveUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/RectanglePrimitiveUpdateStrategy.cs @@ -10,7 +10,7 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Primitives { - internal class RectanglePrimitiveUpdateStrategy : IUpdateStrategy + public class RectanglePrimitiveUpdateStrategy : IUpdateStrategy { private IUpdateStrategy basePrimitiveUpdateStrategy; private IUpdateStrategy divisionPropsUpdateStrategy; @@ -32,7 +32,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives } - public void Update(IRectanglePrimitive targetObject, IRectanglePrimitive sourceObject) + public void Update(IRectangleNdmPrimitive targetObject, IRectangleNdmPrimitive sourceObject) { CheckObject.IsNull(sourceObject, "source object"); CheckObject.IsNull(targetObject, "target object"); diff --git a/StructureHelperLogics/NdmCalculations/Primitives/PointPrimitive.cs b/StructureHelperLogics/NdmCalculations/Primitives/PointNdmPrimitive.cs similarity index 84% rename from StructureHelperLogics/NdmCalculations/Primitives/PointPrimitive.cs rename to StructureHelperLogics/NdmCalculations/Primitives/PointNdmPrimitive.cs index b0d22eb..a99384e 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/PointPrimitive.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/PointNdmPrimitive.cs @@ -9,9 +9,9 @@ using StructureHelperLogics.NdmCalculations.Triangulations; namespace StructureHelperLogics.Models.Primitives { - public class PointPrimitive : IPointPrimitive + public class PointNdmPrimitive : IPointNdmPrimitive { - static readonly PointUpdateStrategy updateStrategy = new(); + static readonly PointPrimitiveUpdateStrategy updateStrategy = new(); public Guid Id { get; } public string? Name { get; set; } public IPoint2D Center { get; set; } @@ -25,19 +25,21 @@ namespace StructureHelperLogics.Models.Primitives public IShape Shape => throw new NotImplementedException(); - public PointPrimitive(Guid id) + public double RotationAngle { get; set; } = 0d; + + public PointNdmPrimitive(Guid id) { Id = id; Name = "New Point"; Area = 0.0005d; Center = new Point2D(); } - public PointPrimitive() : this (Guid.NewGuid()) + public PointNdmPrimitive() : this (Guid.NewGuid()) {} public object Clone() { - var primitive = new PointPrimitive(); + var primitive = new PointNdmPrimitive(); updateStrategy.Update(primitive, this); return primitive; } diff --git a/StructureHelperLogics/NdmCalculations/Primitives/RebarPrimitive.cs b/StructureHelperLogics/NdmCalculations/Primitives/RebarNdmPrimitive.cs similarity index 90% rename from StructureHelperLogics/NdmCalculations/Primitives/RebarPrimitive.cs rename to StructureHelperLogics/NdmCalculations/Primitives/RebarNdmPrimitive.cs index 7b435b6..4b6fc31 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/RebarPrimitive.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/RebarNdmPrimitive.cs @@ -20,9 +20,9 @@ using System.Windows.Media.Media3D; namespace StructureHelperLogics.NdmCalculations.Primitives { /// - public class RebarPrimitive : IRebarPrimitive + public class RebarNdmPrimitive : IRebarNdmPrimitive { - static readonly RebarUpdateStrategy updateStrategy = new(); + static readonly RebarNdmPrimitiveUpdateStrategy updateStrategy = new(); /// public string Name { get; set; } @@ -43,21 +43,23 @@ namespace StructureHelperLogics.NdmCalculations.Primitives public IShape Shape => throw new NotImplementedException(); - public RebarPrimitive(Guid id) + public double RotationAngle { get; set; } = 0d; + + public RebarNdmPrimitive(Guid id) { Id = id; Name = "New Reinforcement"; Area = 0.0005d; Center = new Point2D(); } - public RebarPrimitive() : this(Guid.NewGuid()) + public RebarNdmPrimitive() : this(Guid.NewGuid()) { } public object Clone() { - var primitive = new RebarPrimitive(); + var primitive = new RebarNdmPrimitive(); updateStrategy.Update(primitive, this); return primitive; } diff --git a/StructureHelperLogics/NdmCalculations/Primitives/RectanglePrimitive.cs b/StructureHelperLogics/NdmCalculations/Primitives/RectangleNdmPrimitive.cs similarity index 92% rename from StructureHelperLogics/NdmCalculations/Primitives/RectanglePrimitive.cs rename to StructureHelperLogics/NdmCalculations/Primitives/RectangleNdmPrimitive.cs index 74520a9..11092b3 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/RectanglePrimitive.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/RectangleNdmPrimitive.cs @@ -9,7 +9,7 @@ using StructureHelperLogics.NdmCalculations.Triangulations; namespace StructureHelperLogics.NdmCalculations.Primitives { - public class RectanglePrimitive : IRectanglePrimitive + public class RectangleNdmPrimitive : IRectangleNdmPrimitive { private readonly RectanglePrimitiveUpdateStrategy updateStrategy = new(); private readonly RectangleShape rectangleShape = new(); @@ -17,7 +17,6 @@ namespace StructureHelperLogics.NdmCalculations.Primitives public string Name { get; set; } public double Width { get => rectangleShape.Width; set => rectangleShape.Width = value; } public double Height { get => rectangleShape.Height; set => rectangleShape.Height = value; } - public double Angle { get => rectangleShape.Angle; set => rectangleShape.Angle = value; } public IVisualProperty VisualProperty { get; } = new VisualProperty() { Opacity = 0.8d }; public ICrossSection? CrossSection { get; set; } @@ -29,19 +28,21 @@ namespace StructureHelperLogics.NdmCalculations.Primitives public IShape Shape => rectangleShape; - public RectanglePrimitive(Guid id) + public double RotationAngle { get; set; } = 0d; + + public RectangleNdmPrimitive(Guid id) { Id = id; Name = "New Rectangle"; } - public RectanglePrimitive() : this(Guid.NewGuid()) + public RectangleNdmPrimitive() : this(Guid.NewGuid()) { } public object Clone() { - var primitive = new RectanglePrimitive(); + var primitive = new RectangleNdmPrimitive(); updateStrategy.Update(primitive, this); return primitive; } diff --git a/StructureHelperLogics/NdmCalculations/Triangulations/CircleTriangulationLogicOptions.cs b/StructureHelperLogics/NdmCalculations/Triangulations/CircleTriangulationLogicOptions.cs index 7c5a944..1e83906 100644 --- a/StructureHelperLogics/NdmCalculations/Triangulations/CircleTriangulationLogicOptions.cs +++ b/StructureHelperLogics/NdmCalculations/Triangulations/CircleTriangulationLogicOptions.cs @@ -1,4 +1,5 @@ using StructureHelper.Models.Materials; +using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models.Forces; using StructureHelperCommon.Models.Shapes; using StructureHelperCommon.Services.Forces; @@ -13,9 +14,9 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations { public class CircleTriangulationLogicOptions : IShapeTriangulationLogicOptions { - public ICircleShape Circle { get; } + public ICircleShape Circle { get;} - public IPoint2D Center { get; } + public IPoint2D Center { get; set; } public double NdmMaxSize { get; } @@ -24,8 +25,9 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations public StrainTuple Prestrain { get; set; } public ITriangulationOptions triangulationOptions { get; set; } public IHeadMaterial HeadMaterial { get; set; } + public double RotationAngle { get; set; } - public CircleTriangulationLogicOptions(IEllipsePrimitive primitive) + public CircleTriangulationLogicOptions(IEllipseNdmPrimitive primitive) { Center = primitive.Center.Clone() as Point2D; //to do change to ellipse diff --git a/StructureHelperLogics/NdmCalculations/Triangulations/IShapeTriangulationLogicOptions.cs b/StructureHelperLogics/NdmCalculations/Triangulations/IShapeTriangulationLogicOptions.cs index e1340a3..4d200f4 100644 --- a/StructureHelperLogics/NdmCalculations/Triangulations/IShapeTriangulationLogicOptions.cs +++ b/StructureHelperLogics/NdmCalculations/Triangulations/IShapeTriangulationLogicOptions.cs @@ -1,4 +1,5 @@ -using StructureHelperCommon.Models.Shapes; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Shapes; using System; using System.Collections.Generic; using System.Linq; @@ -7,7 +8,7 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Triangulations { - public interface IShapeTriangulationLogicOptions : ITriangulationLogicOptions + public interface IShapeTriangulationLogicOptions : ITriangulationLogicOptions, IHasCenter2D { /// /// Center of shape diff --git a/StructureHelperLogics/NdmCalculations/Triangulations/PointTriangulationLogicOptions.cs b/StructureHelperLogics/NdmCalculations/Triangulations/PointTriangulationLogicOptions.cs index ce723ca..26805d1 100644 --- a/StructureHelperLogics/NdmCalculations/Triangulations/PointTriangulationLogicOptions.cs +++ b/StructureHelperLogics/NdmCalculations/Triangulations/PointTriangulationLogicOptions.cs @@ -24,7 +24,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations /// - public PointTriangulationLogicOptions(IPointPrimitive primitive) + public PointTriangulationLogicOptions(IPointNdmPrimitive primitive) { Center = primitive.Center.Clone() as Point2D; Area = primitive.Area; diff --git a/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogicOptions.cs b/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogicOptions.cs index 93d728f..5d5fff9 100644 --- a/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogicOptions.cs +++ b/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogicOptions.cs @@ -26,7 +26,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations /// - public RebarTriangulationLogicOptions(RebarPrimitive primitive) + public RebarTriangulationLogicOptions(RebarNdmPrimitive primitive) { Center = primitive.Center.Clone() as Point2D; Area = primitive.Area; diff --git a/StructureHelperLogics/NdmCalculations/Triangulations/RectangleTriangulationLogic.cs b/StructureHelperLogics/NdmCalculations/Triangulations/RectangleTriangulationLogic.cs index a7aeb21..5aed9f5 100644 --- a/StructureHelperLogics/NdmCalculations/Triangulations/RectangleTriangulationLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Triangulations/RectangleTriangulationLogic.cs @@ -25,7 +25,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations Material = options.HeadMaterial.GetLoaderMaterial(options.triangulationOptions.LimiteState, options.triangulationOptions.CalcTerm) }); TriangulationService.CommonTransform(ndmCollection, options); - double angle = options.Rectangle.Angle; + double angle = options.RotationAngle; NdmTransform.Rotate(ndmCollection, angle); TriangulationService.SetPrestrain(ndmCollection, options.Prestrain); return ndmCollection; diff --git a/StructureHelperLogics/NdmCalculations/Triangulations/RectangleTriangulationLogicOptions.cs b/StructureHelperLogics/NdmCalculations/Triangulations/RectangleTriangulationLogicOptions.cs index 8c51c73..54db198 100644 --- a/StructureHelperLogics/NdmCalculations/Triangulations/RectangleTriangulationLogicOptions.cs +++ b/StructureHelperLogics/NdmCalculations/Triangulations/RectangleTriangulationLogicOptions.cs @@ -1,4 +1,5 @@ using StructureHelper.Models.Materials; +using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models.Forces; using StructureHelperCommon.Models.Shapes; using StructureHelperCommon.Services.Forces; @@ -10,7 +11,9 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations public class RectangleTriangulationLogicOptions : IShapeTriangulationLogicOptions { /// - public IPoint2D Center { get; } + public IPoint2D Center { get; set; } + /// + public double RotationAngle { get; set; } = 0d; /// public IRectangleShape Rectangle { get; } /// @@ -31,9 +34,10 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations Prestrain = new StrainTuple(); } - public RectangleTriangulationLogicOptions(IRectanglePrimitive primitive) + public RectangleTriangulationLogicOptions(IRectangleNdmPrimitive primitive) { Center = new Point2D() {X = primitive.Center.X, Y = primitive.Center.Y }; + RotationAngle = primitive.RotationAngle; Rectangle = primitive; NdmMaxSize = primitive.DivisionSize.NdmMaxSize; NdmMinDivision = primitive.DivisionSize.NdmMinDivision; diff --git a/StructureHelperLogics/Services/NdmPrimitives/MeshCrackedConcreteLogic.cs b/StructureHelperLogics/Services/NdmPrimitives/MeshCrackedConcreteLogic.cs index 67a3788..eb5dfd9 100644 --- a/StructureHelperLogics/Services/NdmPrimitives/MeshCrackedConcreteLogic.cs +++ b/StructureHelperLogics/Services/NdmPrimitives/MeshCrackedConcreteLogic.cs @@ -34,7 +34,7 @@ namespace StructureHelperLogics.Services.NdmPrimitives { ProcessICracked(ndmCollection); } - else if (Primitive is RebarPrimitive rebar) + else if (Primitive is RebarNdmPrimitive rebar) { ProcessRebar(ndmCollection, rebar); } @@ -52,10 +52,10 @@ namespace StructureHelperLogics.Services.NdmPrimitives ndmCollection.AddRange(ndms); } - private void ProcessRebar(List ndmCollection, RebarPrimitive rebar) + private void ProcessRebar(List ndmCollection, RebarNdmPrimitive rebar) { TraceLogger?.AddMessage($"Primitive {Primitive.Name} is rebar primitive", TraceLogStatuses.Service); - var newPrimititve = rebar.Clone() as RebarPrimitive; + var newPrimititve = rebar.Clone() as RebarNdmPrimitive; var newHostPrimitive = rebar.HostPrimitive.Clone() as INdmPrimitive; SetNewMaterial(newHostPrimitive); newPrimititve.HostPrimitive = newHostPrimitive; diff --git a/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs b/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs index cdc1b95..b58b9dd 100644 --- a/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs +++ b/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs @@ -51,7 +51,7 @@ namespace StructureHelperTests.UnitTests.Ndms public void Check_RebarPrimitiveFailsCheck_ReturnsFalseAndAppendsCheckResult() { // Arrange - var rebarMock = new Mock(); + var rebarMock = new Mock(); _mockHasPrimitives.Setup(x => x.Primitives).Returns(new List { rebarMock.Object }); _mockCheckRebarPrimitiveLogic.Setup(x => x.Check()).Returns(false); _mockCheckRebarPrimitiveLogic.Setup(x => x.CheckResult).Returns("Rebar check failed\n"); @@ -68,7 +68,7 @@ namespace StructureHelperTests.UnitTests.Ndms public void Check_RebarPrimitiveHasNoHostPrimitive_ReturnsFalseAndLogsError() { // Arrange - var rebarMock = new Mock(); + var rebarMock = new Mock(); var hostPrimitiveMock = new Mock(); rebarMock.Setup(x => x.HostPrimitive).Returns(hostPrimitiveMock.Object); @@ -91,7 +91,7 @@ namespace StructureHelperTests.UnitTests.Ndms public void Check_AllPrimitivesValid_ReturnsTrue() { // Arrange - var rebarMock = new Mock(); + var rebarMock = new Mock(); var hostPrimitiveMock = new Mock(); rebarMock.Setup(x => x.HostPrimitive).Returns(hostPrimitiveMock.Object); diff --git a/StructureHelperTests/UnitTests/Ndms/CheckRebarPrimitiveLogicTests.cs b/StructureHelperTests/UnitTests/Ndms/CheckRebarPrimitiveLogicTests.cs index d82a5d1..a21b310 100644 --- a/StructureHelperTests/UnitTests/Ndms/CheckRebarPrimitiveLogicTests.cs +++ b/StructureHelperTests/UnitTests/Ndms/CheckRebarPrimitiveLogicTests.cs @@ -19,14 +19,14 @@ namespace StructureHelperTests.UnitTests.Ndms [TestFixture] public class CheckRebarPrimitiveLogicTests { - private Mock _mockRebarPrimitive; + private Mock _mockRebarPrimitive; private Mock _mockTraceLogger; private CheckRebarPrimitiveLogic _checkRebarPrimitiveLogic; [SetUp] public void SetUp() { - _mockRebarPrimitive = new Mock(); + _mockRebarPrimitive = new Mock(); _mockTraceLogger = new Mock(); _checkRebarPrimitiveLogic = new CheckRebarPrimitiveLogic(_mockTraceLogger.Object) diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckTupleCalculatorInputDataTests.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckTupleCalculatorInputDataTests.cs index d129e31..ddfb11d 100644 --- a/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckTupleCalculatorInputDataTests.cs +++ b/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckTupleCalculatorInputDataTests.cs @@ -56,7 +56,7 @@ public class CheckTupleCalculatorInputDataTests // Arrange _checkTupleCalculatorInputData.InputData = new TupleCrackInputData { - Primitives = new List { new EllipsePrimitive() }, // Assuming at least one valid primitive + Primitives = new List { new EllipseNdmPrimitive() }, // Assuming at least one valid primitive UserCrackInputData = null }; @@ -74,7 +74,7 @@ public class CheckTupleCalculatorInputDataTests // Arrange _checkTupleCalculatorInputData.InputData = new TupleCrackInputData { - Primitives = new List { new EllipsePrimitive() }, // Assuming at least one valid primitive + Primitives = new List { new EllipseNdmPrimitive() }, // Assuming at least one valid primitive UserCrackInputData = new UserCrackInputData() // Assuming this is valid }; diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/RebarCalulatorsFactoryTests.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/RebarCalulatorsFactoryTests.cs index ae8dee8..396427b 100644 --- a/StructureHelperTests/UnitTests/Ndms/Cracks/RebarCalulatorsFactoryTests.cs +++ b/StructureHelperTests/UnitTests/Ndms/Cracks/RebarCalulatorsFactoryTests.cs @@ -14,7 +14,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks { // Arrange var mockInputFactory = new Mock(); - var rebar = new RebarPrimitive(); + var rebar = new RebarNdmPrimitive(); var inputData = new TupleCrackInputData(); var rebarCrackInputData = new RebarCrackCalculatorInputData(); @@ -26,7 +26,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks var factory = new RebarCalulatorsFactory(mockInputFactory.Object) { - Rebars = new List { rebar }, + Rebars = new List { rebar }, InputData = inputData, LongLength = 10.0, ShortLength = 5.0, @@ -48,8 +48,8 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks { // Arrange var mockInputFactory = new Mock(); - var rebar1 = new RebarPrimitive(); - var rebar2 = new RebarPrimitive(); + var rebar1 = new RebarNdmPrimitive(); + var rebar2 = new RebarNdmPrimitive(); var inputData = new TupleCrackInputData(); var rebarInputData1 = new RebarCrackCalculatorInputData(); var rebarInputData2 = new RebarCrackCalculatorInputData(); @@ -64,7 +64,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks var factory = new RebarCalulatorsFactory(mockInputFactory.Object) { - Rebars = new List { rebar1, rebar2 }, + Rebars = new List { rebar1, rebar2 }, InputData = inputData, LongLength = 20.0, ShortLength = 10.0, diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/RebarStressResultLogicTests.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/RebarStressResultLogicTests.cs index 882b681..8c99ea4 100644 --- a/StructureHelperTests/UnitTests/Ndms/Cracks/RebarStressResultLogicTests.cs +++ b/StructureHelperTests/UnitTests/Ndms/Cracks/RebarStressResultLogicTests.cs @@ -37,7 +37,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks _mockRebarStressCalculator.Setup(x => x.Run()); _mockRebarStressCalculator.Setup(x => x.Result).Returns(mockRebarStressResult); - var mockRebarPrimitive = new Mock(); + var mockRebarPrimitive = new Mock(); var mockRebarCrackInputData = new Mock(); _rebarStressResultLogic.RebarPrimitive = mockRebarPrimitive.Object; @@ -64,7 +64,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks _mockRebarStressCalculator.Setup(x => x.Run()); _mockRebarStressCalculator.Setup(x => x.Result).Returns(mockRebarStressResult); - var mockRebarPrimitive = new Mock(); + var mockRebarPrimitive = new Mock(); var mockRebarCrackInputData = new Mock(); _rebarStressResultLogic.RebarPrimitive = mockRebarPrimitive.Object; diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/TupleRebarCrackSolverTest.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/TupleRebarCrackSolverTest.cs index e0c8a81..b055e93 100644 --- a/StructureHelperTests/UnitTests/Ndms/Cracks/TupleRebarCrackSolverTest.cs +++ b/StructureHelperTests/UnitTests/Ndms/Cracks/TupleRebarCrackSolverTest.cs @@ -25,7 +25,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks var solver = new TupleRebarsCrackSolver(mockCalculatorFactory.Object) { - Rebars = new List(), + Rebars = new List(), InputData = new TupleCrackInputData(), LongLength = 10.0, ShortLength = 5.0, @@ -60,7 +60,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks var solver = new TupleRebarsCrackSolver(mockCalculatorFactory.Object) { - Rebars = new List(), + Rebars = new List(), InputData = new TupleCrackInputData(), LongLength = 10.0, ShortLength = 5.0, diff --git a/StructureHelperTests/UnitTests/Ndms/Triangulations/RectangleTriangulationTest.cs b/StructureHelperTests/UnitTests/Ndms/Triangulations/RectangleTriangulationTest.cs index d0b5106..5b196b5 100644 --- a/StructureHelperTests/UnitTests/Ndms/Triangulations/RectangleTriangulationTest.cs +++ b/StructureHelperTests/UnitTests/Ndms/Triangulations/RectangleTriangulationTest.cs @@ -41,11 +41,12 @@ namespace StructureHelperTests.UnitTests.Ndms.Triangulations .Returns(new Material()); IPoint2D center = new Point2D { X = centerX, Y = centerY }; - IRectangleShape rectangle = new RectangleShape { Width = width, Height = height, Angle = angle }; + IRectangleShape rectangle = new RectangleShape { Width = width, Height = height}; var options = new RectangleTriangulationLogicOptions(center, rectangle, ndmMaxSize, ndmMinDivision) { triangulationOptions = new TriangulationOptions() { LimiteState = LimitStates.ULS, CalcTerm = CalcTerms.ShortTerm }, - HeadMaterial = materialMock.Object + HeadMaterial = materialMock.Object, + RotationAngle = angle }; var logic = new RectangleTriangulationLogic(options); //Act @@ -66,7 +67,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Triangulations //Arrange ProgramSetting.NatSystem = NatSystems.RU; var material = HeadMaterialFactory.GetHeadMaterial(HeadmaterialType.Concrete40); - var mainBlock = new RectanglePrimitive() + var mainBlock = new RectangleNdmPrimitive() { Width = width, Height = height, @@ -75,7 +76,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Triangulations mainBlock.Center.X = centerX; mainBlock.Center.Y = centerY; mainBlock.VisualProperty.ZIndex = 0; - var opening = new RectanglePrimitive() + var opening = new RectangleNdmPrimitive() { Width = 0.3d, Height = 0.2d @@ -109,7 +110,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Triangulations //Arrange ProgramSetting.NatSystem = NatSystems.RU; var material = HeadMaterialFactory.GetHeadMaterial(HeadmaterialType.Concrete40); - var mainBlock = new RectanglePrimitive() + var mainBlock = new RectangleNdmPrimitive() { Width = width, Height = height @@ -118,7 +119,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Triangulations mainBlock.Center.X = centerX; mainBlock.Center.Y = centerY; mainBlock.VisualProperty.ZIndex = 0; - var opening = new EllipsePrimitive() + var opening = new EllipseNdmPrimitive() { Width = 0.3d }; @@ -155,12 +156,12 @@ namespace StructureHelperTests.UnitTests.Ndms.Triangulations //Arrange ProgramSetting.NatSystem = NatSystems.RU; var material = HeadMaterialFactory.GetHeadMaterial(HeadmaterialType.Concrete40); - var mainBlock = new EllipsePrimitive() { Width = diameter}; + var mainBlock = new EllipseNdmPrimitive() { Width = diameter}; mainBlock.NdmElement.HeadMaterial = material; mainBlock.Center.X = centerX; mainBlock.Center.Y = centerY; mainBlock.VisualProperty.ZIndex = 0; - var opening = new RectanglePrimitive() + var opening = new RectangleNdmPrimitive() { Width = 0.3d, Height = 0.2d diff --git a/StructureHelperTests/ViewModelTests/NdmPrimitiveTests.cs b/StructureHelperTests/ViewModelTests/NdmPrimitiveTests.cs index af3a561..51f39f5 100644 --- a/StructureHelperTests/ViewModelTests/NdmPrimitiveTests.cs +++ b/StructureHelperTests/ViewModelTests/NdmPrimitiveTests.cs @@ -26,7 +26,7 @@ namespace StructureHelperTests.ViewModelTests { //Arrange var material = HeadMaterialFactory.GetHeadMaterial(HeadmaterialType.Concrete40); - var primitive = new RectanglePrimitive(); + var primitive = new RectangleNdmPrimitive(); primitive.NdmElement.HeadMaterial = material; var primitiveBase = new RectangleViewPrimitive(primitive); //Act @@ -40,7 +40,7 @@ namespace StructureHelperTests.ViewModelTests //Arrange ProgramSetting.NatSystem = NatSystems.RU; var material = HeadMaterialFactory.GetHeadMaterial(HeadmaterialType.Concrete40); - var primitive = new EllipsePrimitive(); + var primitive = new EllipseNdmPrimitive(); primitive.NdmElement.HeadMaterial = material; var primitiveBase = new CircleViewPrimitive(primitive); //Act @@ -55,7 +55,7 @@ namespace StructureHelperTests.ViewModelTests //Arrange ProgramSetting.NatSystem = NatSystems.RU; var material = HeadMaterialFactory.GetHeadMaterial(HeadmaterialType.Concrete40); - var primitive = new PointPrimitive(); + var primitive = new PointNdmPrimitive(); primitive.NdmElement.HeadMaterial = material; var primitiveBase = new PointViewPrimitive(primitive); //Act @@ -69,7 +69,7 @@ namespace StructureHelperTests.ViewModelTests //Arrange ProgramSetting.NatSystem = NatSystems.RU; var material = HeadMaterialFactory.GetHeadMaterial(HeadmaterialType.Concrete40); - var primitive = new RebarPrimitive(); + var primitive = new RebarNdmPrimitive(); primitive.NdmElement.HeadMaterial = material; var primitiveBase = new ReinforcementViewPrimitive(primitive); //Act