diff --git a/DataAccess/DTOs/Converters/CalculatorToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/CalculatorToDTOConvertStrategy.cs index dd9dba2..602f1ee 100644 --- a/DataAccess/DTOs/Converters/CalculatorToDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/CalculatorToDTOConvertStrategy.cs @@ -4,6 +4,7 @@ using StructureHelperCommon.Models; using StructureHelperCommon.Models.Calculators; using StructureHelperCommon.Models.Loggers; using StructureHelperLogics.NdmCalculations.Analyses.ByForces; +using StructureHelperLogics.NdmCalculations.Analyses.Curvatures; using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams; using StructureHelperLogics.NdmCalculations.Cracking; @@ -65,11 +66,26 @@ namespace DataAccess.DTOs { return ProcessValueDiagramCalcualtor(valueDiagramCalculator); } + if (source is CurvatureCalculator curvatureCalculator) + { + return ProcessCurvatureCalcualtor(curvatureCalculator); + } string errorString = ErrorStrings.ObjectTypeIsUnknownObj(source); TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error); throw new StructureHelperException(errorString); } + private ICalculator ProcessCurvatureCalcualtor(CurvatureCalculator calculator) + { + var convertStrategy = new CurvatureCalculatorToDTOConvertStrategy() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger, + }; + var dictionaryConvertStrategy = new DictionaryConvertStrategy(this, convertStrategy); + return dictionaryConvertStrategy.Convert(calculator); + } + private ValueDiagramCalculatorDTO ProcessValueDiagramCalcualtor(IValueDiagramCalculator valueDiagramCalculator) { var convertStrategy = new ValueDiagramCalculatorToDTOConvertStrategy() @@ -78,7 +94,7 @@ namespace DataAccess.DTOs TraceLogger = TraceLogger }; var dictionaryConvertStrategy = new DictionaryConvertStrategy(this, convertStrategy); - return convertStrategy.Convert(valueDiagramCalculator); + return dictionaryConvertStrategy.Convert(valueDiagramCalculator); } private CrackCalculatorDTO ProcessCrackCalculator(ICrackCalculator crackCalculator) diff --git a/DataAccess/DTOs/Converters/CalculatorsFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/CalculatorsFromDTOConvertStrategy.cs index f562505..8127568 100644 --- a/DataAccess/DTOs/Converters/CalculatorsFromDTOConvertStrategy.cs +++ b/DataAccess/DTOs/Converters/CalculatorsFromDTOConvertStrategy.cs @@ -3,6 +3,7 @@ using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; using StructureHelperCommon.Models.Calculators; using StructureHelperLogics.NdmCalculations.Analyses.ByForces; +using StructureHelperLogics.NdmCalculations.Analyses.Curvatures; using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams; using StructureHelperLogics.NdmCalculations.Cracking; using System; @@ -45,11 +46,26 @@ namespace DataAccess.DTOs TraceLogger?.AddMessage($"{CalculatorIs} value digram calculator"); return GetValueDiagramCalculator(valueDiagramCalculator); } + if (source is CurvatureCalculatorDTO curvatureCalculator) + { + TraceLogger?.AddMessage($"{CalculatorIs} curvature calculator"); + return GetCurvatureCalculator(curvatureCalculator); + } string errorString = ErrorStrings.ObjectTypeIsUnknownObj(source); TraceLogger.AddMessage(errorString, TraceLogStatuses.Error); throw new StructureHelperException(errorString); } + private CurvatureCalculator GetCurvatureCalculator(CurvatureCalculatorDTO calculator) + { + var convertStrategy = new CurvatureCalculatorFromDTOConvertStrategy() + { + ReferenceDictionary = ReferenceDictionary, + TraceLogger = TraceLogger, + }; + return convertStrategy.Convert(calculator); + } + private ValueDiagramCalculator GetValueDiagramCalculator(ValueDiagramCalculatorDTO valueDiagramCalculator) { var convertStrategy = new ValueDiagramCalcualtorFromDTOConvertStrategy() diff --git a/DataAccess/DTOs/Converters/Curvatures/CurvatureCalculatorFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/Curvatures/CurvatureCalculatorFromDTOConvertStrategy.cs new file mode 100644 index 0000000..c84a861 --- /dev/null +++ b/DataAccess/DTOs/Converters/Curvatures/CurvatureCalculatorFromDTOConvertStrategy.cs @@ -0,0 +1,29 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperLogics.NdmCalculations.Analyses.Curvatures; +using System; +using System.Collections.Generic; +using System.Text; + +namespace DataAccess.DTOs +{ + public class CurvatureCalculatorFromDTOConvertStrategy : ConvertStrategy + { + IUpdateStrategy updateStrategy; + IConvertStrategy inputDataConvertStrategy; + IUpdateStrategy UpdateStrategy => updateStrategy ??= new CurvatureCalculatorUpdateStrategy() { UpdateChildren = false }; + IConvertStrategy InputDataConvertStrategy => inputDataConvertStrategy ??= new CurvatureCalculatorInputDataFromDTOConvertStrategy(this); + + public override CurvatureCalculator GetNewItem(CurvatureCalculatorDTO source) + { + NewItem = new(source.Id); + UpdateStrategy.Update(NewItem, source); + if (source.InputData is not CurvatureCalculatorInputDataDTO inputData) + { + throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.InputData) + ": deflection factor"); + } + NewItem.InputData = InputDataConvertStrategy.Convert(inputData); + return NewItem; + } + } +} diff --git a/DataAccess/DTOs/Converters/Curvatures/CurvatureCalculatorInputDataFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/Curvatures/CurvatureCalculatorInputDataFromDTOConvertStrategy.cs new file mode 100644 index 0000000..e85e405 --- /dev/null +++ b/DataAccess/DTOs/Converters/Curvatures/CurvatureCalculatorInputDataFromDTOConvertStrategy.cs @@ -0,0 +1,54 @@ +using DataAccess.DTOs.Converters; +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperLogics.NdmCalculations.Analyses.Curvatures; +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Text; + +namespace DataAccess.DTOs +{ + public class CurvatureCalculatorInputDataFromDTOConvertStrategy : ConvertStrategy + { + private IHasPrimitivesProcessLogic primitivesProcessLogic; + private IHasForceActionsProcessLogic actionsProcessLogic; + private IUpdateStrategy updateStrategy; + private IConvertStrategy deflectionConvertStrategy; + + public CurvatureCalculatorInputDataFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy) + { + } + + private IHasPrimitivesProcessLogic PrimitivesProcessLogic => primitivesProcessLogic ??= new HasPrimitivesProcessLogic(ConvertDirection.FromDTO) { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; + private IHasForceActionsProcessLogic ActionsProcessLogic => actionsProcessLogic ??= new HasForceActionsProcessLogic(ConvertDirection.FromDTO) { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger }; + private IUpdateStrategy UpdateStrategy => updateStrategy ??= new CurvatureCalculatorInputDataUpdateStrategy() { UpdateChildren = false }; + private IConvertStrategy DeflectionConvertStrategy => deflectionConvertStrategy ??= new DeflectionFactorFromDTOConvertStrategy(this); + public override CurvatureCalculatorInputData GetNewItem(CurvatureCalculatorInputDataDTO source) + { + NewItem = new(source.Id); + UpdateStrategy.Update(NewItem, source); + if (source.DeflectionFactor is not DeflectionFactorDTO deflectionFactorDTO) + { + throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.DeflectionFactor) + ": deflection factor"); + } + NewItem.DeflectionFactor = DeflectionConvertStrategy.Convert(deflectionFactorDTO); + ProcessPrimitives(source); + ProcessActions(source); + return NewItem; + } + + private void ProcessPrimitives(IHasPrimitives source) + { + PrimitivesProcessLogic.Source = source; + PrimitivesProcessLogic.Target = NewItem; + PrimitivesProcessLogic.Process(); + } + private void ProcessActions(IHasForceActions source) + { + ActionsProcessLogic.Source = source; + ActionsProcessLogic.Target = NewItem; + ActionsProcessLogic.Process(); + } + } +} diff --git a/DataAccess/DTOs/Converters/Curvatures/CurvatureCalculatorInputDataToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/Curvatures/CurvatureCalculatorInputDataToDTOConvertStrategy.cs new file mode 100644 index 0000000..2918a7c --- /dev/null +++ b/DataAccess/DTOs/Converters/Curvatures/CurvatureCalculatorInputDataToDTOConvertStrategy.cs @@ -0,0 +1,47 @@ +using DataAccess.DTOs.Converters; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperLogics.NdmCalculations.Analyses.Curvatures; +using StructureHelperLogics.NdmCalculations.Primitives; + +namespace DataAccess.DTOs +{ + public class CurvatureCalculatorInputDataToDTOConvertStrategy : ConvertStrategy + { + private IHasPrimitivesProcessLogic primitivesProcessLogic; + private IHasForceActionsProcessLogic actionsProcessLogic; + private IUpdateStrategy updateStrategy; + private IConvertStrategy deflectionConvertStrategy; + + private IHasPrimitivesProcessLogic PrimitivesProcessLogic => primitivesProcessLogic ??= new HasPrimitivesProcessLogic(ConvertDirection.ToDTO) { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger}; + private IHasForceActionsProcessLogic ActionsProcessLogic => actionsProcessLogic ??= new HasForceActionsProcessLogic(ConvertDirection.ToDTO) { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger}; + private IUpdateStrategy UpdateStrategy => updateStrategy ??= new CurvatureCalculatorInputDataUpdateStrategy() { UpdateChildren = false}; + private IConvertStrategy DeflectionConvertStrategy => deflectionConvertStrategy ??= new DeflectionFactorToDTOConvertStrategy(this); + + public CurvatureCalculatorInputDataToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy) + { + } + + public override CurvatureCalculatorInputDataDTO GetNewItem(ICurvatureCalculatorInputData source) + { + NewItem = new(source.Id); + UpdateStrategy.Update(NewItem, source); + NewItem.DeflectionFactor = DeflectionConvertStrategy.Convert(source.DeflectionFactor); + ProcessPrimitives(source); + ProcessActions(source); + return NewItem; + } + + private void ProcessPrimitives(IHasPrimitives source) + { + PrimitivesProcessLogic.Source = source; + PrimitivesProcessLogic.Target = NewItem; + PrimitivesProcessLogic.Process(); + } + private void ProcessActions(IHasForceActions source) + { + ActionsProcessLogic.Source = source; + ActionsProcessLogic.Target = NewItem; + ActionsProcessLogic.Process(); + } + } +} diff --git a/DataAccess/DTOs/Converters/Curvatures/CurvatureCalculatorToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/Curvatures/CurvatureCalculatorToDTOConvertStrategy.cs new file mode 100644 index 0000000..9c6013d --- /dev/null +++ b/DataAccess/DTOs/Converters/Curvatures/CurvatureCalculatorToDTOConvertStrategy.cs @@ -0,0 +1,22 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperLogics.NdmCalculations.Analyses.Curvatures; + +namespace DataAccess.DTOs +{ + public class CurvatureCalculatorToDTOConvertStrategy : ConvertStrategy + { + IUpdateStrategy updateStrategy; + IConvertStrategy inputDataConvertStrategy; + IUpdateStrategy UpdateStrategy => updateStrategy ??= new CurvatureCalculatorUpdateStrategy() { UpdateChildren = false}; + IConvertStrategy InputDataConvertStrategy => inputDataConvertStrategy ??= new CurvatureCalculatorInputDataToDTOConvertStrategy(this); + + + public override CurvatureCalculatorDTO GetNewItem(ICurvatureCalculator source) + { + NewItem = new(source.Id); + UpdateStrategy.Update(NewItem, source); + NewItem.InputData = InputDataConvertStrategy.Convert(source.InputData); + return NewItem; + } + } +} diff --git a/DataAccess/DTOs/Converters/Curvatures/DeflectionFactorFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/Curvatures/DeflectionFactorFromDTOConvertStrategy.cs new file mode 100644 index 0000000..a334330 --- /dev/null +++ b/DataAccess/DTOs/Converters/Curvatures/DeflectionFactorFromDTOConvertStrategy.cs @@ -0,0 +1,37 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Forces; +using StructureHelperLogics.NdmCalculations.Analyses.Curvatures; + +namespace DataAccess.DTOs +{ + public class DeflectionFactorFromDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy updateStrategy; + private IConvertStrategy forceTupleConvertStrategy; + + public DeflectionFactorFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy) + { + } + + private IUpdateStrategy UpdateStrategy => updateStrategy ??= new DeflectionFactorUpdateStrategy() { UpdateChildren = false }; + private IConvertStrategy ForceTupleConvertStrategy => forceTupleConvertStrategy ??= new ForceTupleFromDTOConvertStrategy(ReferenceDictionary, TraceLogger); + + public override DeflectionFactor GetNewItem(DeflectionFactorDTO source) + { + NewItem = new(source.Id); + UpdateStrategy.Update(NewItem, source); + if (source.DeflectionFactors is not ForceTupleDTO deflectionFactor) + { + throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.DeflectionFactors) + ": deflection factor"); + } + NewItem.DeflectionFactors = ForceTupleConvertStrategy.Convert(deflectionFactor); + if (source.MaxDeflections is not ForceTupleDTO maxDeflections) + { + throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.MaxDeflections) + ": maximum deflections"); + } + NewItem.MaxDeflections = ForceTupleConvertStrategy.Convert(maxDeflections); + return NewItem; + } + } +} diff --git a/DataAccess/DTOs/Converters/Curvatures/DeflectionFactorToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/Curvatures/DeflectionFactorToDTOConvertStrategy.cs new file mode 100644 index 0000000..9dbcd34 --- /dev/null +++ b/DataAccess/DTOs/Converters/Curvatures/DeflectionFactorToDTOConvertStrategy.cs @@ -0,0 +1,26 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Forces; +using StructureHelperLogics.NdmCalculations.Analyses.Curvatures; + +namespace DataAccess.DTOs +{ + public class DeflectionFactorToDTOConvertStrategy : ConvertStrategy + { + private IUpdateStrategy updateStrategy; + private IConvertStrategy forceTupleConvertStrategy; + private IUpdateStrategy UpdateStrategy => updateStrategy??= new DeflectionFactorUpdateStrategy() { UpdateChildren = false}; + private IConvertStrategy ForceTupleConvertStrategy => forceTupleConvertStrategy ??= new ForceTupleToDTOConvertStrategy(ReferenceDictionary, TraceLogger); + + public DeflectionFactorToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy) + { + } + public override DeflectionFactorDTO GetNewItem(IDeflectionFactor source) + { + NewItem = new(source.Id); + UpdateStrategy.Update(NewItem, source); + NewItem.DeflectionFactors = ForceTupleConvertStrategy.Convert(source.DeflectionFactors); + NewItem.MaxDeflections = ForceTupleConvertStrategy.Convert(source.MaxDeflections); + return NewItem; + } + } +} diff --git a/DataAccess/DTOs/DTOEntities/Curvatures/CurvatureCalculatorDTO.cs b/DataAccess/DTOs/DTOEntities/Curvatures/CurvatureCalculatorDTO.cs new file mode 100644 index 0000000..6a0bdee --- /dev/null +++ b/DataAccess/DTOs/DTOEntities/Curvatures/CurvatureCalculatorDTO.cs @@ -0,0 +1,41 @@ +using Newtonsoft.Json; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Calculators; +using StructureHelperLogics.NdmCalculations.Analyses.Curvatures; +using System; +using System.Collections.Generic; +using System.Text; + +namespace DataAccess.DTOs +{ + public class CurvatureCalculatorDTO : ICurvatureCalculator + { + [JsonProperty("Id")] + public Guid Id { get; } + [JsonProperty("Name")] + public string Name { get; set; } + [JsonProperty("InputData")] + public ICurvatureCalculatorInputData InputData { get; set; } + [JsonProperty("ShowTraceData")] + public bool ShowTraceData { get; set; } + [JsonIgnore] + public IResult Result => throw new NotImplementedException(); + [JsonIgnore] + public IShiftTraceLogger? TraceLogger { get; set; } + public CurvatureCalculatorDTO(Guid id) + { + Id = id; + } + + + public object Clone() + { + throw new NotImplementedException(); + } + + public void Run() + { + throw new NotImplementedException(); + } + } +} diff --git a/DataAccess/DTOs/DTOEntities/Curvatures/CurvatureCalculatorInputDataDTO.cs b/DataAccess/DTOs/DTOEntities/Curvatures/CurvatureCalculatorInputDataDTO.cs new file mode 100644 index 0000000..2785a9d --- /dev/null +++ b/DataAccess/DTOs/DTOEntities/Curvatures/CurvatureCalculatorInputDataDTO.cs @@ -0,0 +1,26 @@ +using Newtonsoft.Json; +using StructureHelperCommon.Models.Forces; +using StructureHelperLogics.NdmCalculations.Analyses.Curvatures; +using StructureHelperLogics.NdmCalculations.Primitives; +using System; +using System.Collections.Generic; +using System.Text; + +namespace DataAccess.DTOs +{ + public class CurvatureCalculatorInputDataDTO : ICurvatureCalculatorInputData + { + [JsonProperty("Id")] + public Guid Id { get; } + [JsonProperty("DesignFactor")] + public IDeflectionFactor DeflectionFactor { get; set; } + [JsonProperty("ForceActions")] + public List ForceActions { get; } = []; + [JsonProperty("Primitives")] + public List Primitives { get; } = []; + public CurvatureCalculatorInputDataDTO(Guid id) + { + Id = id; + } + } +} diff --git a/DataAccess/DTOs/DTOEntities/Curvatures/DeflectionFactorDTO.cs b/DataAccess/DTOs/DTOEntities/Curvatures/DeflectionFactorDTO.cs new file mode 100644 index 0000000..ec00c8f --- /dev/null +++ b/DataAccess/DTOs/DTOEntities/Curvatures/DeflectionFactorDTO.cs @@ -0,0 +1,24 @@ +using Newtonsoft.Json; +using StructureHelperCommon.Models.Forces; +using StructureHelperLogics.NdmCalculations.Analyses.Curvatures; + +namespace DataAccess.DTOs +{ + public class DeflectionFactorDTO : IDeflectionFactor + { + [JsonProperty("Id")] + public Guid Id { get; } + [JsonProperty("DeflectionFactors")] + public IForceTuple DeflectionFactors { get; set; } + [JsonProperty("SpanLength")] + public double SpanLength { get; set; } + [JsonProperty("MaxDeflections")] + public IForceTuple MaxDeflections { get; set; } + + + public DeflectionFactorDTO(Guid id) + { + Id = id; + } + } +} diff --git a/DataAccess/DTOs/DTOEntities/TypeBinderListFactory.cs b/DataAccess/DTOs/DTOEntities/TypeBinderListFactory.cs index eca6c79..a53cdd3 100644 --- a/DataAccess/DTOs/DTOEntities/TypeBinderListFactory.cs +++ b/DataAccess/DTOs/DTOEntities/TypeBinderListFactory.cs @@ -58,6 +58,18 @@ namespace DataAccess.DTOs newList.AddRange(GetNdmPrimitiveList()); newList.AddRange(GetBeamShearList()); newList.AddRange(GetValueDiagramList()); + newList.AddRange(GetCurvatureList()); + return newList; + } + + private static IEnumerable<(Type type, string name)> GetCurvatureList() + { + List<(Type type, string name)> newList = new() + { + { (typeof(CurvatureCalculatorDTO), "CurvatureCalculator") }, + { (typeof(CurvatureCalculatorInputDataDTO), "CurvatureCalculatorInputData") }, + { (typeof(DeflectionFactorDTO), "DeflectionFactor") }, + }; return newList; } diff --git a/StructureHelper/StructureHelper.csproj.user b/StructureHelper/StructureHelper.csproj.user index 977dd49..bf1f821 100644 --- a/StructureHelper/StructureHelper.csproj.user +++ b/StructureHelper/StructureHelper.csproj.user @@ -63,6 +63,9 @@ Code + + Code + Code diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorInputDataViewModel.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorInputDataViewModel.cs index d2fcaa6..d0e969b 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorInputDataViewModel.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorInputDataViewModel.cs @@ -1,41 +1,19 @@ using StructureHelper.Infrastructure; using StructureHelper.Infrastructure.UI.DataContexts; using StructureHelper.Windows.ViewModels; -using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelper.Windows.ViewModels.Forces; using StructureHelperCommon.Models.Forces; using StructureHelperLogics.Models.CrossSections; using StructureHelperLogics.NdmCalculations.Analyses.Curvatures; using System; -using System.Collections.Generic; -using System.Text; namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.Curvatures { public class CurvatureCalculatorInputDataViewModel : ViewModelBase { private ICurvatureCalculatorInputData inputData; - private double deflectionFactor; - private double spanLength; - public double DeflectionFactor - { - get => inputData.DeflectionFactor; - set - { - inputData.DeflectionFactor = Math.Max(value, 0.0); - OnPropertyChanged(nameof(DeflectionFactor)); - } - } - - public double SpanLength - { - get => inputData.SpanLength; - set - { - inputData.SpanLength = Math.Max(value, 0.0); - OnPropertyChanged(nameof(SpanLength)); - } - } + public DeflectionFactorViewModel DeflectionFactor { get; } public SourceTargetVM CombinationViewModel { get; } public SourceTargetVM PrimitivesViewModel { get; } @@ -45,6 +23,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.Curvatures this.inputData = inputData; CombinationViewModel = SourceTargetFactory.GetSourceTargetVM(repository.ForceActions, inputData.ForceActions); PrimitivesViewModel = SourceTargetFactory.GetSourceTargetVM(repository.Primitives, inputData.Primitives); + DeflectionFactor = new(inputData.DeflectionFactor); } public void Refresh() { diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorResultView.xaml b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorResultView.xaml new file mode 100644 index 0000000..ffbab6e --- /dev/null +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorResultView.xaml @@ -0,0 +1,101 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorResultView.xaml.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorResultView.xaml.cs new file mode 100644 index 0000000..82c56ba --- /dev/null +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorResultView.xaml.cs @@ -0,0 +1,23 @@ +using StructureHelperLogics.NdmCalculations.Analyses.Curvatures; +using System.Windows; + +namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.Curvatures +{ + /// + /// Логика взаимодействия для CurvatureCalculatorResultView.xaml + /// + public partial class CurvatureCalculatorResultView : Window + { + private readonly CurvatureCalculatorResultViewModel viewModel; + public CurvatureCalculatorResultView(CurvatureCalculatorResultViewModel viewModel) + { + InitializeComponent(); + this.viewModel = viewModel; + this.DataContext = viewModel; + } + + public CurvatureCalculatorResultView(ICurvatureCalculatorResult? curvatureResult) : this(new CurvatureCalculatorResultViewModel(curvatureResult)) + { + } + } +} diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorResultViewModel.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorResultViewModel.cs new file mode 100644 index 0000000..c5a91a1 --- /dev/null +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorResultViewModel.cs @@ -0,0 +1,29 @@ +using StructureHelper.Infrastructure; +using StructureHelperLogics.NdmCalculations.Analyses.Curvatures; +using System; +using System.Collections.Generic; +using System.Text; + +namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.Curvatures +{ + public class CurvatureCalculatorResultViewModel : ViewModelBase + { + private readonly ICurvatureCalculatorResult resultModel; + public CurvatureForceCalculatorResultViewModel SelectedResult { get; set; } + public List ForcesResult { get; set; } + public ICurvatureCalculatorResult Result => resultModel; + public ValidResultCounterVM ValidResultCounter { get; } + + public CurvatureCalculatorResultViewModel(ICurvatureCalculatorResult resultModel) + { + this.resultModel = resultModel; + ValidResultCounter = new(this.resultModel.ForceCalculatorResults); + ForcesResult = new(); + foreach (var item in resultModel.ForceCalculatorResults) + { + ForcesResult.Add(new CurvatureForceCalculatorResultViewModel(item)); + } + } + + } +} diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorView.xaml b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorView.xaml index 66a30a7..0a8000c 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorView.xaml +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorView.xaml @@ -7,7 +7,7 @@ xmlns:uc="clr-namespace:StructureHelper.Windows.UserControls" d:DataContext="{d:DesignInstance local:CurvatureCalculatorViewModel}" mc:Ignorable="d" - Title="Curvature Calculator" Height="250" Width="400" WindowStartupLocation="CenterScreen" ResizeMode="NoResize"> + Title="Curvature Calculator" Height="250" Width="400" WindowStartupLocation="CenterScreen" ResizeMode="NoResize" Closing="Window_Closing"> @@ -23,18 +23,13 @@ - - + - - - - @@ -43,6 +38,62 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorView.xaml.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorView.xaml.cs index a61559a..84d4fe0 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorView.xaml.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureCalculatorView.xaml.cs @@ -15,5 +15,10 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.Curvatures this.viewModel = viewModel; this.DataContext = viewModel; } + + private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e) + { + viewModel.Refresh(); + } } } diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureForceCalculatorResultViewModel.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureForceCalculatorResultViewModel.cs new file mode 100644 index 0000000..fa055d2 --- /dev/null +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/CurvatureForceCalculatorResultViewModel.cs @@ -0,0 +1,18 @@ +using StructureHelper.Infrastructure; +using StructureHelperLogics.NdmCalculations.Analyses.Curvatures; +using System; +using System.Collections.Generic; +using System.Text; + +namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.Curvatures +{ + public class CurvatureForceCalculatorResultViewModel : ViewModelBase + { + private readonly ICurvatureForceCalculatorResult resultModel; + + public CurvatureForceCalculatorResultViewModel(ICurvatureForceCalculatorResult resultModel) + { + this.resultModel = resultModel; + } + } +} diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/DeflectionFactorViewModel.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/DeflectionFactorViewModel.cs new file mode 100644 index 0000000..5b00edf --- /dev/null +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/Curvatures/DeflectionFactorViewModel.cs @@ -0,0 +1,44 @@ +using StructureHelper.Infrastructure; +using StructureHelper.Windows.ViewModels.Forces; +using StructureHelperCommon.Models.Calculators; +using StructureHelperLogics.NdmCalculations.Analyses.Curvatures; +using System; +using System.Collections.Generic; +using System.Text; + +namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.Curvatures +{ + public class DeflectionFactorViewModel : ViewModelBase + { + IDeflectionFactor deflectionFactor; + public ForceTupleVM DeflectionFactors { get; } + public ForceTupleVM MaxDeflections { get; } + + public double SpanLength + { + get => deflectionFactor.SpanLength; + set + { + deflectionFactor.SpanLength = Math.Max(value, 0.0); + OnPropertyChanged(nameof(SpanLength)); + } + } + + public DeflectionFactorViewModel(IDeflectionFactor deflectionFactor) + { + this.deflectionFactor = deflectionFactor; + DeflectionFactors = new(this.deflectionFactor.DeflectionFactors) + { + MinMx = 0.0, + MinMy = 0.0, + MinNz = 0.0 + }; + MaxDeflections = new(this.deflectionFactor.MaxDeflections) + { + MinMx = 0.0, + MinMy = 0.0, + MinNz = 0.0 + }; + } + } +} diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForcesResultsViewModel.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForcesResultsViewModel.cs index a3541ba..de3020f 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForcesResultsViewModel.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForcesResultsViewModel.cs @@ -307,7 +307,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu } private void SetPrestrain() { - var source = TupleConverter.ConvertToStrainTuple(SelectedResult.ForcesTupleResult.LoaderResults.StrainMatrix); + var source = ForceTupleConverter.ConvertToStrainTuple(SelectedResult.ForcesTupleResult.LoaderResults.StrainMatrix); var vm = new SetPrestrainViewModel(source); var wnd = new SetPrestrainView(vm); wnd.ShowDialog(); diff --git a/StructureHelper/Windows/MainWindow/CrossSections/AnalysisViewModelLogic.cs b/StructureHelper/Windows/MainWindow/CrossSections/AnalysisViewModelLogic.cs index 8bb4aea..7bceae7 100644 --- a/StructureHelper/Windows/MainWindow/CrossSections/AnalysisViewModelLogic.cs +++ b/StructureHelper/Windows/MainWindow/CrossSections/AnalysisViewModelLogic.cs @@ -1,5 +1,4 @@ -using LoaderCalculator; -using StructureHelper.Infrastructure; +using StructureHelper.Infrastructure; using StructureHelper.Infrastructure.Enums; using StructureHelper.Windows.CalculationWindows.CalculatorsViews; using StructureHelper.Windows.CalculationWindows.CalculatorsViews.Curvatures; @@ -298,6 +297,12 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections ValueDiagramLogic valueDiagramLogic = new(diagramCalcualtorResult); valueDiagramLogic.Show(); } + else if (SelectedItem is ICurvatureCalculator curvatureCalculator) + { + ICurvatureCalculatorResult curvatureResult = curvatureCalculator.Result as ICurvatureCalculatorResult; + var wnd = new CurvatureCalculatorResultView(curvatureResult); + wnd.ShowDialog(); + } else { throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(SelectedItem)); diff --git a/StructureHelper/Windows/ViewModels/Forces/ForceTupleVM.cs b/StructureHelper/Windows/ViewModels/Forces/ForceTupleVM.cs index 027e91f..4074d64 100644 --- a/StructureHelper/Windows/ViewModels/Forces/ForceTupleVM.cs +++ b/StructureHelper/Windows/ViewModels/Forces/ForceTupleVM.cs @@ -1,10 +1,6 @@ using StructureHelper.Infrastructure; using StructureHelperCommon.Models.Forces; using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace StructureHelper.Windows.ViewModels.Forces { @@ -16,7 +12,8 @@ namespace StructureHelper.Windows.ViewModels.Forces get => forceTuple.Mx; set { - forceTuple.Mx = value; + forceTuple.Mx = Math.Max(value, MinMx); + forceTuple.Mx = Math.Min(value, MaxMx); OnPropertyChanged(nameof(Mx)); } } @@ -25,7 +22,8 @@ namespace StructureHelper.Windows.ViewModels.Forces get => forceTuple.My; set { - forceTuple.My = value; + forceTuple.My = Math.Max(value, MinMy); + forceTuple.My = Math.Min(value, MaxMy); OnPropertyChanged(nameof(My)); } } @@ -34,7 +32,8 @@ namespace StructureHelper.Windows.ViewModels.Forces get => forceTuple.Nz; set { - forceTuple.Nz = value; + forceTuple.Nz = Math.Max(value, MinNz); + forceTuple.Nz = Math.Min(value, MaxNz); OnPropertyChanged(nameof(Nz)); } } @@ -65,6 +64,20 @@ namespace StructureHelper.Windows.ViewModels.Forces OnPropertyChanged(nameof(Mz)); } } + + public double MaxMx { get; set; } = double.PositiveInfinity; + public double MinMx { get; set; } = double.NegativeInfinity; + public double MaxMy { get; set; } = double.PositiveInfinity; + public double MinMy { get; set; } = double.NegativeInfinity; + public double MaxNz { get; set; } = double.PositiveInfinity; + public double MinNz { get; set; } = double.NegativeInfinity; + public double MaxMz { get; set; } = double.PositiveInfinity; + public double MinMz { get; set; } = double.NegativeInfinity; + public double MaxQx { get; set; } = double.PositiveInfinity; + public double MinQx { get; set; } = double.NegativeInfinity; + public double MaxQy { get; set; } = double.PositiveInfinity; + public double MinQy { get; set; } = double.NegativeInfinity; + public ForceTupleVM(IForceTuple forceTuple) { this.forceTuple = forceTuple; diff --git a/StructureHelperCommon/Services/Forces/TupleConverter.cs b/StructureHelperCommon/Services/Forces/ForceTupleConverter.cs similarity index 83% rename from StructureHelperCommon/Services/Forces/TupleConverter.cs rename to StructureHelperCommon/Services/Forces/ForceTupleConverter.cs index 54e841a..4bc6122 100644 --- a/StructureHelperCommon/Services/Forces/TupleConverter.cs +++ b/StructureHelperCommon/Services/Forces/ForceTupleConverter.cs @@ -8,7 +8,7 @@ using System.Collections.Generic; namespace StructureHelperCommon.Services.Forces { - public static class TupleConverter + public static class ForceTupleConverter { static readonly IStressLogic stressLogic = new StressLogic(); public static StrainMatrix ConvertToLoaderStrainMatrix(StrainTuple strainTuple) @@ -29,6 +29,17 @@ namespace StructureHelperCommon.Services.Forces return strainTuple; } + public static ForceTuple ConvertToForceTuple(IStrainMatrix strainMatrix) + { + ForceTuple strainTuple = new() + { + Mx = strainMatrix.Kx, + My = strainMatrix.Ky, + Nz = strainMatrix.EpsZ + }; + return strainTuple; + } + public static ForceTuple ConvertToForceTuple(IEnumerable ndms, StrainTuple strainTuple) { var strainMatrix = ConvertToLoaderStrainMatrix(strainTuple); diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs index 81f4110..c0b2fed 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/CheckForceCalculatorInputData.cs @@ -69,7 +69,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces private void CheckPrimitives() { - checkPrimitiveCollectionLogic ??= new CheckPrimitiveCollectionLogic( + checkPrimitiveCollectionLogic ??= new HasPrimitivesCheckLogic( TraceLogger, new CheckRebarPrimitiveLogic() { diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleInputData.cs index 5ea5753..34bb415 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/ForceTupleInputData.cs @@ -12,12 +12,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces /// public IForceTuple ForceTuple { get; set; } /// - public IAccuracy Accuracy { get; set; } - public bool CheckStrainLimit { get; set; } - - public ForceTupleInputData() - { - Accuracy ??= new Accuracy() { IterationAccuracy = 0.01d, MaxIterationCount = 1000 }; - } + public IAccuracy Accuracy { get; set; } = new Accuracy() { IterationAccuracy = 0.01d, MaxIterationCount = 1000 }; + public bool CheckStrainLimit { get; set; } = true; } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/Factories/PredicateFactory.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/Factories/PredicateFactory.cs index b189d3c..61c7195 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/Factories/PredicateFactory.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/LimitCurve/Factories/PredicateFactory.cs @@ -91,7 +91,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces Mx = point3D.X, My = point3D.Y }; - logic.Tuple = tuple; + logic.ForceTuple = tuple; logic.SectionNdmCollection = Ndms; try { diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CalculatorCloningStrategyContainer.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CalculatorCloningStrategyContainer.cs index 8efd992..edd265a 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CalculatorCloningStrategyContainer.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CalculatorCloningStrategyContainer.cs @@ -1,5 +1,6 @@ using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve; +using StructureHelperLogics.NdmCalculations.Analyses.Curvatures; using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams; using StructureHelperLogics.NdmCalculations.Cracking; using System; @@ -11,7 +12,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics public class CalculatorCloningStrategyContainer : ICalculatorCloningStrategyContainer { private ICloningStrategy cloningStrategy; - + private IUpdateStrategy valueDiagramCalculatorStrategy; + private IUpdateStrategy curvatureCalculatorStrategy; public IUpdateStrategy ForceCalculatorStrategy => new ForceCalculatorUpdateCloningStrategy(cloningStrategy); @@ -19,7 +21,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics public IUpdateStrategy LimitCurvesCalculatorStrategy => new LimitCurvesCalculatorUpdateCloningStrategy(cloningStrategy); - public IUpdateStrategy ValueDiagramCalculatorStrategy => new ValueDiagramCalculatorUpdateCloningStrategy(cloningStrategy); + public IUpdateStrategy ValueDiagramCalculatorStrategy => valueDiagramCalculatorStrategy ??= new ValueDiagramCalculatorUpdateCloningStrategy(cloningStrategy); + public IUpdateStrategy CurvatureCalculatorStrategy => curvatureCalculatorStrategy ??= new CurvatureCalculatorUpdateCloningStrategy(cloningStrategy); public CalculatorCloningStrategyContainer(ICloningStrategy cloningStrategy) { this.cloningStrategy = cloningStrategy; diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/HasCalculatorsUpdateCloningStrategy.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/HasCalculatorsUpdateCloningStrategy.cs index 04e50b1..7336776 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/HasCalculatorsUpdateCloningStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/HasCalculatorsUpdateCloningStrategy.cs @@ -6,6 +6,7 @@ using StructureHelperCommon.Models.Parameters; using StructureHelperCommon.Services; using StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve; using StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics; +using StructureHelperLogics.NdmCalculations.Analyses.Curvatures; using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams; using StructureHelperLogics.NdmCalculations.Cracking; using StructureHelperLogics.NdmCalculations.Primitives; @@ -65,6 +66,10 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces { cloningStrategyContainer.ValueDiagramCalculatorStrategy.Update(newCalculator as IValueDiagramCalculator, valueDiagramCalculator); } + else if (calculator is ICurvatureCalculator curvatureCalculator) + { + cloningStrategyContainer.CurvatureCalculatorStrategy.Update(newCalculator as ICurvatureCalculator, curvatureCalculator); + } else { throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(calculator)); diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ICalculatorCloningStrategyContainer.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ICalculatorCloningStrategyContainer.cs index 17f56d3..f19ac0f 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ICalculatorCloningStrategyContainer.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ICalculatorCloningStrategyContainer.cs @@ -1,4 +1,5 @@ using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperLogics.NdmCalculations.Analyses.Curvatures; using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams; using StructureHelperLogics.NdmCalculations.Cracking; @@ -10,5 +11,6 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces IUpdateStrategy CrackCalculatorStrategy { get; } IUpdateStrategy LimitCurvesCalculatorStrategy { get; } IUpdateStrategy ValueDiagramCalculatorStrategy { get; } + IUpdateStrategy CurvatureCalculatorStrategy { get; } } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/SofteningFactorLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/SofteningFactorLogic.cs index afba5f4..5b7481a 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/SofteningFactorLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/SofteningFactorLogic.cs @@ -27,7 +27,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics TraceLogger?.AddMessage($"Logic of analisys based on calculating sum of secant stifness of elementary parts EA,i = A,i * Esec,i"); TraceLogger?.AddMessage($"Calculating geometry properties for strains"); TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(StrainTuple)); - var loaderStainMatrix = TupleConverter.ConvertToLoaderStrainMatrix(StrainTuple); + var loaderStainMatrix = ForceTupleConverter.ConvertToLoaderStrainMatrix(StrainTuple); var (MxFactor, MyFactor, NzFactor) = GeometryOperations.GetSofteningsFactors(NdmCollection, loaderStainMatrix); TraceLogger?.AddMessage($"Reducing of stiffness in {ProgramSetting.GeometryNames.SndAxisName}-plane: EIx_cracked / EIx_uncracked = {MxFactor}"); TraceLogger?.AddMessage($"Reducing of stiffness in {ProgramSetting.GeometryNames.FstAxisName}-plane: EIy_cracked / EIy_uncracked = {MyFactor}"); diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureCalculator.cs index 4da4451..2962e17 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureCalculator.cs @@ -1,4 +1,5 @@ -using StructureHelperCommon.Models; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; using StructureHelperCommon.Models.Calculators; using System; using System.Collections.Generic; @@ -8,7 +9,13 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures { public class CurvatureCalculator : ICurvatureCalculator { - private ICurvatureCalculatorResult result; + private CurvatureCalculatorResult result; + private ICheckEntityLogic inputDataCheckLogic; + private ICurvatureCalcualtorLogic calculatorLogic; + private ICurvatureCalcualtorLogic CalculatorLogic => calculatorLogic ??= new CurvatureCalculatorLogic() { InputData = InputData, TraceLogger = TraceLogger}; + + private ICheckEntityLogic InputDataCheckLogic => inputDataCheckLogic ??= new CurvatureCalculatorInputDataCheckLogic(TraceLogger) { Entity = InputData}; + public Guid Id { get; } public string Name { get; set; } = string.Empty; public ICurvatureCalculatorInputData InputData { get; set; } = new CurvatureCalculatorInputData(Guid.NewGuid()); @@ -34,7 +41,43 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures public void Run() { - throw new NotImplementedException(); + PrepareNewResult(); + if (CheckInputData() == false) {return;} + GetResultByLogic(); + } + + private void GetResultByLogic() + { + try + { + CalculatorLogic.Run(); + result = CalculatorLogic.Result as CurvatureCalculatorResult; + } + catch (Exception ex) + { + result.IsValid = false; + result.Description += ex.Message; + } + } + + private void PrepareNewResult() + { + result = new() + { + IsValid = true, + InputData = InputData, + }; + } + + private bool CheckInputData() + { + if (InputDataCheckLogic.Check() == false) + { + result.IsValid = false; + result.Description += inputDataCheckLogic.CheckResult; + return false; + } + return true; } } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureCalculatorInputData.cs index f35da72..0a802f1 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureCalculatorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureCalculatorInputData.cs @@ -9,8 +9,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures public List ForceActions { get; } = []; public List Primitives { get; } = []; - public double DeflectionFactor { get; set; } = 0.1042; - public double SpanLength { get; set; } = 6.0; + public IDeflectionFactor DeflectionFactor { get; set; } = new DeflectionFactor(Guid.NewGuid()); public CurvatureCalculatorInputData(Guid id) { diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureCalculatorResult.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureCalculatorResult.cs new file mode 100644 index 0000000..e709e4d --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureCalculatorResult.cs @@ -0,0 +1,12 @@ +namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures +{ + public class CurvatureCalculatorResult : ICurvatureCalculatorResult + { + public ICurvatureCalculatorInputData InputData { get; set; } + + public List ForceCalculatorResults { get; } = []; + + public bool IsValid { get; set; } = true; + public string? Description { get; set; } = string.Empty; + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureForceCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureForceCalculator.cs new file mode 100644 index 0000000..5cdf5eb --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureForceCalculator.cs @@ -0,0 +1,87 @@ +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Forces; +using StructureHelperLogics.NdmCalculations.Cracking; +using StructureHelperLogics.Services.NdmPrimitives; + +namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures +{ + public class CurvatureForceCalculator : ICurvatureForceCalculator + { + private CurvatureForceCalculatorResult result; + public ICurvatureForceCalculatorInputData InputData { get; set; } + + public IResult Result => result; + + public IShiftTraceLogger? TraceLogger { get; set; } + + public Guid Id => throw new NotImplementedException(); + + public object Clone() + { + throw new NotImplementedException(); + } + + public void Run() + { + PrepareResult(); + if (CheckForCracks(InputData.ShortTermTuple, CalcTerms.ShortTerm) || CheckForCracks(InputData.ShortTermTuple, CalcTerms.ShortTerm)) + { + ProcessCrackedSection(); + } + else + { + ProcessUncrackedSection(); + } + } + + private void ProcessCrackedSection() + { + throw new NotImplementedException(); + } + + private void ProcessUncrackedSection() + { + CurvatureTermCalculatorInputData inputData = new() + { + Primitives = InputData.Primitives, + DeflectionFactor = InputData.DeflectionFactor + }; + var calculator = new CurvatureTermUncrackedCalculator() { InputData = inputData }; + inputData.ForceTuple = InputData.LongTermTuple; + inputData.CalculationTerm = CalcTerms.LongTerm; + calculator.Run(); + var calcResult = calculator.Result as CurvatureTermCalculatorResult; + if (calcResult.IsValid == false) + { + result.IsValid = false; + } + result.LongTermResult = calcResult; + } + + private bool CheckForCracks(IForceTuple forceTuple, CalcTerms calcTerm) + { + var triangulateLogic = new TriangulatePrimitiveLogic() + { + Primitives = InputData.Primitives, + LimitState = LimitStates.SLS, + CalcTerm = calcTerm, + TraceLogger = TraceLogger + }; + var ndms = triangulateLogic.GetNdms(); + var logic = new IsSectionCrackedByForceLogic() + { + ForceTuple = forceTuple, + CheckedNdmCollection = ndms, + SectionNdmCollection = ndms + }; + return logic.IsSectionCracked(); + } + + private void PrepareResult() + { + result = new(); + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureForceCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureForceCalculatorInputData.cs new file mode 100644 index 0000000..3cfc43e --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureForceCalculatorInputData.cs @@ -0,0 +1,13 @@ +using StructureHelperCommon.Models.Forces; +using StructureHelperLogics.NdmCalculations.Primitives; + +namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures +{ + public class CurvatureForceCalculatorInputData : ICurvatureForceCalculatorInputData + { + public IForceTuple LongTermTuple { get; set; } + public IForceTuple ShortTermTuple { get; set; } + public List Primitives { get; set; } = []; + public IDeflectionFactor DeflectionFactor { get; set; } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureForceCalculatorResult.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureForceCalculatorResult.cs new file mode 100644 index 0000000..614571d --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureForceCalculatorResult.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures +{ + public class CurvatureForceCalculatorResult : ICurvatureForceCalculatorResult + { + public ICurvatureForceCalculatorInputData InputData { get; set; } + public ICurvatureTermCalculatorResult LongTermResult { get; set; } + public ICurvatureTermCalculatorResult ShortTermResult { get; set; } + public bool IsValid { get; set; } = true; + public string? Description { get; set; } = string.Empty; + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermCalcualtor.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermCalcualtor.cs index 7dc4cf0..6aabd26 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermCalcualtor.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermCalcualtor.cs @@ -6,10 +6,10 @@ using System.Text; namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures { - public class CurvatureTermCalcualtor : ICurvatureTermCalcualtor + public class CurvatureTermCalcualtor : ICurvatureTermCalculator { - private ICurvatureTermCalcualtorResult result; - public ICurvatureTermCalcualtorInputData InputData { get; set; } + private ICurvatureTermCalculatorResult result; + public ICurvatureTermCalculatorInputData InputData { get; set; } public IResult Result => result; diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermCalculatorInputData.cs new file mode 100644 index 0000000..71da5a1 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermCalculatorInputData.cs @@ -0,0 +1,16 @@ +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models.Forces; +using StructureHelperLogics.NdmCalculations.Primitives; + +namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures +{ + public class CurvatureTermCalculatorInputData : ICurvatureTermCalculatorInputData + { + public IForceTuple ForceTuple { get; set; } + public CalcTerms LoadTerm { get; set; } + public CalcTerms CalculationTerm { get; set; } + + public List Primitives { get; set; } = []; + public IDeflectionFactor DeflectionFactor { get; set; } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermCalculatorResult.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermCalculatorResult.cs new file mode 100644 index 0000000..03e3223 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermCalculatorResult.cs @@ -0,0 +1,16 @@ +using StructureHelperCommon.Models.Forces; +using System; +using System.Collections.Generic; +using System.Text; + +namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures +{ + public class CurvatureTermCalculatorResult : ICurvatureTermCalculatorResult + { + public ICurvatureTermCalculatorInputData InputData { get; set; } + public IForceTuple CurvatureValues { get; set; } + public IForceTuple Deflections { get; set; } + public bool IsValid { get; set; } = true; + public string? Description { get; set; } = string.Empty; + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermUncrackedCalculator.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermUncrackedCalculator.cs new file mode 100644 index 0000000..5bad429 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/CurvatureTermUncrackedCalculator.cs @@ -0,0 +1,98 @@ +using LoaderCalculator.Data.Ndms; +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Services.Forces; +using StructureHelperLogics.NdmCalculations.Analyses.ByForces; +using StructureHelperLogics.Services.NdmPrimitives; +using System; +using System.Collections.Generic; +using System.Text; + +namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures +{ + public class CurvatureTermUncrackedCalculator : ICurvatureTermCalculator + { + private CurvatureTermCalculatorResult result; + private List ndms; + + public ICurvatureTermCalculatorInputData InputData { get; set; } + + public IResult Result => result; + + public IShiftTraceLogger? TraceLogger { get; set; } + + public Guid Id => throw new NotImplementedException(); + + public object Clone() + { + throw new NotImplementedException(); + } + + public void Run() + { + PrepareNewResult(); + TriangulatePrimitives(); + Calculate(); + } + + private void Calculate() + { + try + { + var inputData = new ForceTupleInputData() + { + NdmCollection = ndms, + ForceTuple = InputData.ForceTuple + }; + var calculator = new ForceTupleCalculator() + { + InputData = inputData, + }; + calculator.Run(); + var calcResult = calculator.Result as IForceTupleCalculatorResult; + if (calcResult.IsValid != true) + { + result.IsValid = false; + result.Description += calcResult.Description; + return; + } + result.CurvatureValues = ForceTupleConverter.ConvertToForceTuple(calcResult.LoaderResults.StrainMatrix); + ConvertCurvaturesToDeflections(); + } + catch (Exception ex) + { + result.IsValid = false; + result.Description = ex.Message; + } + } + + private void ConvertCurvaturesToDeflections() + { + ForceTuple deflections = new(); + double spanLength = InputData.DeflectionFactor.SpanLength; + deflections.Mx = InputData.DeflectionFactor.DeflectionFactors.Mx * result.CurvatureValues.Mx * spanLength * spanLength; + deflections.My = InputData.DeflectionFactor.DeflectionFactors.My * result.CurvatureValues.My * spanLength * spanLength; + deflections.Nz = InputData.DeflectionFactor.DeflectionFactors.Nz * result.CurvatureValues.Nz * spanLength; + result.Deflections = deflections; + } + + private void TriangulatePrimitives() + { + var triangulateLogic = new TriangulatePrimitiveLogic() + { + Primitives = InputData.Primitives, + LimitState = LimitStates.SLS, + CalcTerm = InputData.CalculationTerm, + TraceLogger = TraceLogger + }; + ndms = triangulateLogic.GetNdms(); + } + + private void PrepareNewResult() + { + result = new(); + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/DeflectionFactor.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/DeflectionFactor.cs new file mode 100644 index 0000000..400ee72 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/DeflectionFactor.cs @@ -0,0 +1,43 @@ +using StructureHelperCommon.Models.Forces; +using System; +using System.Collections.Generic; +using System.Text; + +namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures +{ + public class DeflectionFactor : IDeflectionFactor + { + private const double bendCurveFactor = 0.1042; + private const double longitudinalFactor = 1.0; + private const double maxDeflection = 0.02; + + public IForceTuple DeflectionFactors { get; set; } + public double SpanLength { get; set; } = 6.0; + public IForceTuple MaxDeflections { get; set; } + + public Guid Id { get; } + + public DeflectionFactor(Guid id) + { + Id = id; + DeflectionFactors = new ForceTuple() + { + Mx = bendCurveFactor, + My = bendCurveFactor, + Mz = longitudinalFactor, + Nz = longitudinalFactor, + Qx = longitudinalFactor, + Qy = longitudinalFactor + }; + MaxDeflections = new ForceTuple() + { + Mx = maxDeflection, + My = maxDeflection, + Mz = maxDeflection, + Nz = maxDeflection, + Qx = maxDeflection, + Qy = maxDeflection, + }; + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureCalculatorInputData.cs index 00c0805..2d45f65 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureCalculatorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureCalculatorInputData.cs @@ -1,15 +1,15 @@ using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Forces; using StructureHelperLogics.NdmCalculations.Primitives; -using System; -using System.Collections.Generic; -using System.Text; namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures { + /// + /// Input data for calculator of curvature of cross-section + /// public interface ICurvatureCalculatorInputData : IInputData, ISaveable, IHasForceActions, IHasPrimitives { - double DeflectionFactor { get; set; } - double SpanLength { get; set; } + IDeflectionFactor DeflectionFactor { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalcualtor.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalculator.cs similarity index 61% rename from StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalcualtor.cs rename to StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalculator.cs index 1c12bb9..3ff2e4e 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalcualtor.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalculator.cs @@ -5,7 +5,8 @@ using System.Text; namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures { - public interface ICurvatureForceCalcualtor : ILogicCalculator + public interface ICurvatureForceCalculator : ILogicCalculator { + ICurvatureForceCalculatorInputData InputData { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalculatorInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalculatorInputData.cs index 866e0e4..7d8df26 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalculatorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalculatorInputData.cs @@ -1,14 +1,13 @@ using StructureHelperCommon.Models.Calculators; using StructureHelperCommon.Models.Forces; using StructureHelperLogics.NdmCalculations.Primitives; -using System; -using System.Collections.Generic; -using System.Text; namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures { public interface ICurvatureForceCalculatorInputData : IInputData, IHasPrimitives { - IDesignForceTuple DesignForceTuple { get; set; } + IForceTuple LongTermTuple { get; set; } + IForceTuple ShortTermTuple { get; set; } + IDeflectionFactor DeflectionFactor { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalculatorResult.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalculatorResult.cs index 8ada475..b238606 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalculatorResult.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureForceCalculatorResult.cs @@ -5,7 +5,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures public interface ICurvatureForceCalculatorResult : IResult { ICurvatureForceCalculatorInputData InputData { get; set; } - ICurvatureTermCalcualtorResult LongTermResult { get; set; } - ICurvatureTermCalcualtorResult ShortTermResult { get; set; } + ICurvatureTermCalculatorResult LongTermResult { get; set; } + ICurvatureTermCalculatorResult ShortTermResult { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalcualtorResult.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalcualtorResult.cs deleted file mode 100644 index 50678df..0000000 --- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalcualtorResult.cs +++ /dev/null @@ -1,13 +0,0 @@ -using StructureHelperCommon.Models.Calculators; -using StructureHelperCommon.Models.Forces; - -namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures -{ - public interface ICurvatureTermCalcualtorResult : IResult - { - ICurvatureTermCalcualtorInputData InputData { get; set; } - IForceTuple CurvatureValue { get; set; } - IForceTuple Deflection { get; set; } - - } -} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalcualtor.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalculator.cs similarity index 61% rename from StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalcualtor.cs rename to StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalculator.cs index 3ac1c81..bbe0a63 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalcualtor.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalculator.cs @@ -5,8 +5,8 @@ using System.Text; namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures { - public interface ICurvatureTermCalcualtor : ILogicCalculator + public interface ICurvatureTermCalculator : ILogicCalculator { - ICurvatureTermCalcualtorInputData InputData { get; set; } + ICurvatureTermCalculatorInputData InputData { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalcualtorInputData.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalculatorInputData.cs similarity index 70% rename from StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalcualtorInputData.cs rename to StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalculatorInputData.cs index fcb7deb..efa2342 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalcualtorInputData.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalculatorInputData.cs @@ -5,10 +5,11 @@ using StructureHelperLogics.NdmCalculations.Primitives; namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures { - public interface ICurvatureTermCalcualtorInputData : IInputData, IHasPrimitives + public interface ICurvatureTermCalculatorInputData : IInputData, IHasPrimitives { - IForceTuple DesignForceTuple { get; set; } + IForceTuple ForceTuple { get; set; } CalcTerms LoadTerm { get; set; } CalcTerms CalculationTerm { get; set; } + IDeflectionFactor DeflectionFactor { get; set; } } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalculatorResult.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalculatorResult.cs new file mode 100644 index 0000000..10aa06c --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureTermCalculatorResult.cs @@ -0,0 +1,13 @@ +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Forces; + +namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures +{ + public interface ICurvatureTermCalculatorResult : IResult + { + ICurvatureTermCalculatorInputData InputData { get; set; } + IForceTuple CurvatureValues { get; set; } + IForceTuple Deflections { get; set; } + + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/IDeflectionFactor.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/IDeflectionFactor.cs new file mode 100644 index 0000000..bd65526 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/IDeflectionFactor.cs @@ -0,0 +1,24 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Forces; +using System; +using System.Collections.Generic; +using System.Text; + +namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures +{ + /// + /// Implements properties for calculation deflections + /// + public interface IDeflectionFactor : ISaveable + { + /// + /// Factors for calculating deflections, dimensionless + /// + IForceTuple DeflectionFactors { get; set; } + /// + /// Maximum deflections, metres + /// + double SpanLength { get; set; } + IForceTuple MaxDeflections { get; set; } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorInputDataCheckLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorInputDataCheckLogic.cs new file mode 100644 index 0000000..2277b65 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorInputDataCheckLogic.cs @@ -0,0 +1,78 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Forces.Logics; +using StructureHelperLogics.NdmCalculations.Primitives; +using StructureHelperLogics.NdmCalculations.Primitives.Logics; + +namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures +{ + public class CurvatureCalculatorInputDataCheckLogic : CheckEntityLogic + { + private ICheckEntityLogic primitivesCheckLogic; + private ICheckEntityLogic> actionsCheckLogic; + private bool result; + + private ICheckEntityLogic> ActionsCheckLogic => actionsCheckLogic ??= new CheckForceActionsLogic(TraceLogger); + + private ICheckEntityLogic PrimitivesCheckLogic => primitivesCheckLogic ??= new HasPrimitivesCheckLogic(); + + public CurvatureCalculatorInputDataCheckLogic(IShiftTraceLogger traceLogger) + { + TraceLogger = traceLogger; + CheckRebarPrimitiveLogic checkRebarPrimitiveLogic = new() + { + CheckRebarHostMaterial = false, + CheckRebarPlacement = false + }; + primitivesCheckLogic = new HasPrimitivesCheckLogic(TraceLogger, checkRebarPrimitiveLogic); + } + + public override bool Check() + { + result = true; + if (Entity is null) + { + string errorString = ErrorStrings.ParameterIsNull + ": curvature calculator input data"; + TraceMessage(errorString); + throw new StructureHelperException(errorString); + } + if (Entity.Primitives is null || !Entity.Primitives.Any()) + { + TraceMessage("Calculator does not contain any primitives"); + result = false; + } + if (Entity.ForceActions is null || !Entity.ForceActions.Any()) + { + TraceMessage("Calculator does not contain any forces"); + result = false; + } + CheckPrimitives(); + CheckActions(); + return result; + } + + private void CheckPrimitives() + { + PrimitivesCheckLogic.Entity = Entity; + if (PrimitivesCheckLogic.Check() == false) + { + result = false; + } + TraceMessage(PrimitivesCheckLogic.CheckResult); + + } + + private void CheckActions() + { + ActionsCheckLogic.Entity = Entity.ForceActions; + if (ActionsCheckLogic.Check() == false) + { + result = false; + } + TraceMessage(ActionsCheckLogic.CheckResult); + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorInputDataUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorInputDataUpdateStrategy.cs index 7b29fb7..48d043a 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorInputDataUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorInputDataUpdateStrategy.cs @@ -5,6 +5,9 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures { public class CurvatureCalculatorInputDataUpdateStrategy : IParentUpdateStrategy { + private IUpdateStrategy deflectionUpdateStrategy; + private IUpdateStrategy DeflectionUpdateStrategy => deflectionUpdateStrategy ??= new DeflectionFactorUpdateStrategy(); + public bool UpdateChildren { get; set; } = true; public void Update(ICurvatureCalculatorInputData targetObject, ICurvatureCalculatorInputData sourceObject) @@ -13,19 +16,23 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures CheckObject.ThrowIfNull(targetObject, nameof(targetObject)); if (ReferenceEquals(targetObject, sourceObject)) return; - targetObject.DeflectionFactor = sourceObject.DeflectionFactor; - targetObject.SpanLength = sourceObject.SpanLength; + if (UpdateChildren == true) { - CheckObject.ThrowIfNull(sourceObject.Primitives); - CheckObject.ThrowIfNull(targetObject.Primitives); + CheckProperties(targetObject, sourceObject); targetObject.Primitives.Clear(); targetObject.Primitives.AddRange(sourceObject.Primitives); - CheckObject.ThrowIfNull(sourceObject.ForceActions); - CheckObject.ThrowIfNull(targetObject.ForceActions); targetObject.ForceActions.Clear(); targetObject.ForceActions.AddRange(sourceObject.ForceActions); } } + + private static void CheckProperties(ICurvatureCalculatorInputData targetObject, ICurvatureCalculatorInputData sourceObject) + { + CheckObject.ThrowIfNull(sourceObject.Primitives); + CheckObject.ThrowIfNull(targetObject.Primitives); + CheckObject.ThrowIfNull(sourceObject.ForceActions); + CheckObject.ThrowIfNull(targetObject.ForceActions); + } } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorLogic.cs new file mode 100644 index 0000000..6bda049 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorLogic.cs @@ -0,0 +1,99 @@ +using LoaderCalculator.Data.Ndms; +using StructureHelperCommon.Infrastructures.Enums; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Models.Sections; +using StructureHelperCommon.Models.Sections.Logics; +using StructureHelperCommon.Models.Shapes; +using StructureHelperLogics.Services.NdmPrimitives; +using System; + +namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures +{ + public class CurvatureCalculatorLogic : ICurvatureCalcualtorLogic + { + private const LimitStates limitState = LimitStates.SLS; + private CurvatureCalculatorResult result; + private ICurvatureForceCalculator forceCalculator; + private ICurvatureForceCalculator ForceCalculator => forceCalculator ??= new CurvatureForceCalculator(); + private IPoint2D gravityCenter; + + public ICurvatureCalculatorInputData InputData { get; set; } + + public IResult Result => result; + + public IShiftTraceLogger? TraceLogger { get; set; } + + public void Run() + { + PrepareNewResult(); + SetGravityCenter(); + try + { + Calculate(); + } + catch (Exception ex) + { + result.IsValid = false; + result.Description += ex.Message; + } + } + + private void Calculate() + { + foreach (var action in InputData.ForceActions) + { + var combinationList = action.GetCombinations(); + foreach (var combination in combinationList) + { + var longTuple = combination.DesignForces.Single(x => x.LimitState == limitState && x.CalcTerm == CalcTerms.LongTerm).ForceTuple; + var shortTuple = combination.DesignForces.Single(x => x.LimitState == limitState && x.CalcTerm == CalcTerms.ShortTerm).ForceTuple; + if (action.SetInGravityCenter == true) + { + IProcessorLogic forceLogic = new ForceTupleCopier(longTuple); + forceLogic = new ForceTupleMoveToPointDecorator(forceLogic) { Point2D = gravityCenter }; + longTuple = forceLogic.GetValue(); + forceLogic = new ForceTupleCopier(shortTuple); + forceLogic = new ForceTupleMoveToPointDecorator(forceLogic) { Point2D = gravityCenter }; + shortTuple = forceLogic.GetValue(); + } + CurvatureForceCalculatorInputData forceInputData = new() + { + LongTermTuple = longTuple, + ShortTermTuple = shortTuple, + Primitives = InputData.Primitives, + DeflectionFactor = InputData.DeflectionFactor + }; + ForceCalculator.InputData = forceInputData; + ForceCalculator.Run(); + result.ForceCalculatorResults.Add((ICurvatureForceCalculatorResult)ForceCalculator.Result); + } + } + } + + private void SetGravityCenter() + { + var triangulateLogic = new TriangulatePrimitiveLogic() + { + Primitives = InputData.Primitives, + LimitState = LimitStates.ULS, + CalcTerm = CalcTerms.ShortTerm, + TraceLogger = TraceLogger + }; + var ndms = triangulateLogic.GetNdms(); + var (Cx, Cy) = LoaderCalculator.Logics.Geometry.GeometryOperations.GetGravityCenter(ndms); + gravityCenter = new Point2D() { X = Cx, Y = Cy }; + } + + private void PrepareNewResult() + { + result = new CurvatureCalculatorResult() + { + IsValid = true, + Description = string.Empty, + InputData = InputData + }; + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorUpdateCloningStrategy.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorUpdateCloningStrategy.cs new file mode 100644 index 0000000..d1dd293 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/CurvatureCalculatorUpdateCloningStrategy.cs @@ -0,0 +1,46 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Services; +using StructureHelperLogics.NdmCalculations.Primitives; +using StructureHelperLogics.NdmCalculations.Primitives.Logics; +using System; +using System.Collections.Generic; +using System.Text; + +namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures +{ + public class CurvatureCalculatorUpdateCloningStrategy : IUpdateStrategy + { + private readonly ICloningStrategy cloningStrategy; + private IUpdateStrategy forcesUpdateStrategy; + private IUpdateStrategy primitivesUpdateStrategy; + private IUpdateStrategy ForcesUpdateStrategy => forcesUpdateStrategy ??= new HasForceActionUpdateCloningStrategy(cloningStrategy); + private IUpdateStrategy PrimitivesUpdateStrategy => primitivesUpdateStrategy ??= new HasPrimitivesUpdateCloningStrategy(cloningStrategy); + + public CurvatureCalculatorUpdateCloningStrategy(ICloningStrategy cloningStrategy) + { + this.cloningStrategy = cloningStrategy; + } + + public CurvatureCalculatorUpdateCloningStrategy( + ICloningStrategy cloningStrategy, + IUpdateStrategy forcesUpdateStrategy, + IUpdateStrategy primitivesUpdateStrategy) + { + this.cloningStrategy = cloningStrategy; + this.forcesUpdateStrategy = forcesUpdateStrategy; + this.primitivesUpdateStrategy = primitivesUpdateStrategy; + } + + public void Update(ICurvatureCalculator targetObject, ICurvatureCalculator sourceObject) + { + CheckObject.ThrowIfNull(cloningStrategy); + CheckObject.ThrowIfNull(sourceObject); + CheckObject.ThrowIfNull(targetObject); + if (ReferenceEquals(targetObject, sourceObject)) { return; } + var sourceData = sourceObject.InputData; + var targetData = targetObject.InputData; + PrimitivesUpdateStrategy.Update(targetData, sourceData); + ForcesUpdateStrategy.Update(targetData, sourceData); + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/DeflectionFactorUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/DeflectionFactorUpdateStrategy.cs new file mode 100644 index 0000000..656d12a --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/DeflectionFactorUpdateStrategy.cs @@ -0,0 +1,32 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Forces; +using StructureHelperCommon.Services; +using System; +using System.Collections.Generic; +using System.Text; + +namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures +{ + public class DeflectionFactorUpdateStrategy : IParentUpdateStrategy + { + public bool UpdateChildren { get; set; } = true; + + public void Update(IDeflectionFactor targetObject, IDeflectionFactor sourceObject) + { + CheckObject.ThrowIfNull(sourceObject, nameof(sourceObject)); + CheckObject.ThrowIfNull(targetObject, nameof(targetObject)); + if (ReferenceEquals(targetObject, sourceObject)) + return; + targetObject.SpanLength = sourceObject.SpanLength; + if (UpdateChildren == true) + { + CheckObject.ThrowIfNull(sourceObject.DeflectionFactors); + CheckObject.ThrowIfNull(targetObject.DeflectionFactors); + CheckObject.ThrowIfNull(sourceObject.MaxDeflections); + CheckObject.ThrowIfNull(targetObject.MaxDeflections); + targetObject.DeflectionFactors = sourceObject.DeflectionFactors.Clone() as IForceTuple; + targetObject.MaxDeflections = sourceObject.MaxDeflections.Clone() as IForceTuple; + } + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureCalcualtorLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/ICurvatureCalcualtorLogic.cs similarity index 61% rename from StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureCalcualtorLogic.cs rename to StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/ICurvatureCalcualtorLogic.cs index ec80695..c636a89 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/ICurvatureCalcualtorLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/Curvatures/Logics/ICurvatureCalcualtorLogic.cs @@ -1,11 +1,12 @@ -using StructureHelperCommon.Models.Calculators; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Calculators; using System; using System.Collections.Generic; using System.Text; namespace StructureHelperLogics.NdmCalculations.Analyses.Curvatures { - internal interface ICurvatureCalcualtorLogic + internal interface ICurvatureCalcualtorLogic : ILogic { ICurvatureCalculatorInputData InputData {get;set;} IResult Result { get; } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorLogic.cs index d3c5f26..f319256 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorLogic.cs @@ -61,7 +61,6 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams var newTuple = forcelogic.GetValue(); GetForceTupleResult(forceAction, newTuple); } - } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorUpdateCloningStrategy.cs b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorUpdateCloningStrategy.cs index d1fd839..7843de7 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorUpdateCloningStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorUpdateCloningStrategy.cs @@ -8,13 +8,12 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams public class ValueDiagramCalculatorUpdateCloningStrategy : IUpdateStrategy { private readonly ICloningStrategy cloningStrategy; - private readonly IUpdateStrategy forcesUpdateStrategy; - private readonly IUpdateStrategy primitivesUpdateStrategy; + private IUpdateStrategy forcesUpdateStrategy; + private IUpdateStrategy primitivesUpdateStrategy; + private IUpdateStrategy ForcesUpdateStrategy => forcesUpdateStrategy ??= new HasForceActionUpdateCloningStrategy(cloningStrategy); + private IUpdateStrategy PrimitivesUpdateStrategy => primitivesUpdateStrategy ??= new HasPrimitivesUpdateCloningStrategy(cloningStrategy); - public ValueDiagramCalculatorUpdateCloningStrategy(ICloningStrategy cloningStrategy) : this( - cloningStrategy, - new HasForceActionUpdateCloningStrategy(cloningStrategy), - new HasPrimitivesUpdateCloningStrategy(cloningStrategy)) + public ValueDiagramCalculatorUpdateCloningStrategy(ICloningStrategy cloningStrategy) { this.cloningStrategy = cloningStrategy; } @@ -37,8 +36,8 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams if (ReferenceEquals(targetObject, sourceObject)) { return; } var sourceData = sourceObject.InputData; var targetData = targetObject.InputData; - primitivesUpdateStrategy.Update(targetData, sourceData); - forcesUpdateStrategy.Update(targetData, sourceData); + PrimitivesUpdateStrategy.Update(targetData, sourceData); + ForcesUpdateStrategy.Update(targetData, sourceData); } } } diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCheckLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCheckLogic.cs index 486b5ff..aa3ccdf 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCheckLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCheckLogic.cs @@ -6,11 +6,10 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams.Logics public class ValueDiagramCheckLogic : CheckEntityLogic { private const double minDistance = 1e-3; - private bool result; public override bool Check() { - result = true; + bool result = true; if (Entity is null) { string errorString = ErrorStrings.ParameterIsNull + ": value diagram"; diff --git a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramInputDataCheckLogic.cs b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramInputDataCheckLogic.cs index 14c9cee..8b49776 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramInputDataCheckLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramInputDataCheckLogic.cs @@ -33,7 +33,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams CheckRebarHostMaterial = false, CheckRebarPlacement = false }; - primitivesCheckLogic = new CheckPrimitiveCollectionLogic(TraceLogger, checkRebarPrimitiveLogic); + primitivesCheckLogic = new HasPrimitivesCheckLogic(TraceLogger, checkRebarPrimitiveLogic); actionsCheckLogic = new CheckForceActionsLogic(TraceLogger); } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs index 5e00981..389fa1b 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CheckLogics/CheckCrackCalculatorInputDataLogic.cs @@ -28,7 +28,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking this.checkPrimitiveCollectionLogic = checkPrimitiveCollectionLogic; } - public CheckCrackCalculatorInputDataLogic() : this (new CheckPrimitiveCollectionLogic()) + public CheckCrackCalculatorInputDataLogic() : this (new HasPrimitivesCheckLogic()) { } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceBynarySearchCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackForceBynarySearchCalculator.cs index 34c95ba..8c538c3 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackForceBynarySearchCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackForceBynarySearchCalculator.cs @@ -199,7 +199,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking forceTupleCalculator.Run(); var result = forceTupleCalculator.Result as IForceTupleCalculatorResult; var loaderStrainMatrix = result.LoaderResults.ForceStrainPair.StrainMatrix; - StrainTuple strainTuple = TupleConverter.ConvertToStrainTuple(loaderStrainMatrix); + StrainTuple strainTuple = ForceTupleConverter.ConvertToStrainTuple(loaderStrainMatrix); return strainTuple; } private bool CheckInputData() diff --git a/StructureHelperLogics/NdmCalculations/Cracking/CrackedConcreteNdmLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/CrackedConcreteNdmLogic.cs index 86c7e50..2d69823 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/CrackedConcreteNdmLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/CrackedConcreteNdmLogic.cs @@ -15,7 +15,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking /// public INdm ConcreteNdm { get; set; } /// - public IForceTuple Tuple { get; set; } + public IForceTuple ForceTuple { get; set; } /// public IEnumerable CheckedNdmCollection { get; set; } /// diff --git a/StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCracked.cs b/StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCracked.cs new file mode 100644 index 0000000..345b053 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCracked.cs @@ -0,0 +1,13 @@ +using StructureHelperCommon.Infrastructures.Interfaces; + +namespace StructureHelperLogics.NdmCalculations.Cracking +{ + public interface IIsSectionCracked : ILogic + { + /// + /// Returns result of checking of cracks appearence + /// + /// True if Checked collectition contains cracked elements + bool IsSectionCracked(); + } +} \ No newline at end of file diff --git a/StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCrackedByForceLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCrackedByForceLogic.cs index 3226b72..52eb626 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCrackedByForceLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/IIsSectionCrackedByForceLogic.cs @@ -1,23 +1,17 @@ using LoaderCalculator.Data.Ndms; -using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models.Forces; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Cracking { /// /// Logic for checking collection of ndms for appearance of crack /// - public interface IIsSectionCrackedByForceLogic : ILogic + public interface IIsSectionCrackedByForceLogic : IIsSectionCracked { /// /// Force tuple for checking of cracks appearence /// - IForceTuple Tuple { get; set; } + IForceTuple ForceTuple { get; set; } /// /// Collection of ndms which is checking for cracking /// @@ -26,10 +20,5 @@ namespace StructureHelperLogics.NdmCalculations.Cracking /// Full ndms collection of cross-section /// IEnumerable SectionNdmCollection { get; set; } - /// - /// Returns result of checking of cracks appearence - /// - /// True if Checked collectition contains cracked elements - bool IsSectionCracked(); } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByFactorLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByFactorLogic.cs index ca89be0..da2a009 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByFactorLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByFactorLogic.cs @@ -32,7 +32,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { IsSectionCrackedByForceLogic.TraceLogger ??= TraceLogger?.GetSimilarTraceLogger(50); var actualTuple = ForceTupleService.InterpolateTuples(StartTuple, EndTuple, factor); - IsSectionCrackedByForceLogic.Tuple = actualTuple; + IsSectionCrackedByForceLogic.ForceTuple = actualTuple; return IsSectionCrackedByForceLogic.IsSectionCracked(); } } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByForceLogic.cs b/StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByForceLogic.cs index 2f8e61f..49f07a2 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByForceLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/IsSectionCrackedByForceLogic.cs @@ -14,33 +14,22 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { static readonly IStressLogic stressLogic = new StressLogic(); /// - public IForceTuple Tuple { get; set; } + public IForceTuple ForceTuple { get; set; } public IEnumerable CheckedNdmCollection { get; set; } public IEnumerable SectionNdmCollection { get; set; } - public Accuracy Accuracy { get; set; } + public Accuracy Accuracy { get; set; } = new Accuracy() { IterationAccuracy = 0.001d, MaxIterationCount = 10000}; public IShiftTraceLogger? TraceLogger { get; set; } - public IsSectionCrackedByForceLogic() - { - if (Accuracy is null) - { - Accuracy = new Accuracy() - { - IterationAccuracy = 0.001d, - MaxIterationCount = 10000 - }; - } - } public bool IsSectionCracked() { TraceLogger?.AddMessage($"Calculator type: {GetType()}", TraceLogStatuses.Service); TraceLogger?.AddMessage($"It is assumed, that cracks appearence if: cross-section has elementary parts of concrete and strain of concrete greater than limit value"); TraceLogger?.AddMessage($"Force combination for cracking check"); - TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(Tuple)); + TraceLogger?.AddEntry(new TraceTablesFactory().GetByForceTuple(ForceTuple)); var inputData = new ForceTupleInputData() { Accuracy = Accuracy, - ForceTuple = Tuple, + ForceTuple = ForceTuple, NdmCollection = SectionNdmCollection }; var calculator = new ForceTupleCalculator() { InputData = inputData }; diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs index 50fd4ea..fd38971 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarStressCalculator.cs @@ -60,7 +60,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { var strainTuple = GetStrainTuple(); result.StrainTuple = strainTuple; - var strainMatrix = TupleConverter.ConvertToLoaderStrainMatrix(strainTuple); + var strainMatrix = ForceTupleConverter.ConvertToLoaderStrainMatrix(strainTuple); result.RebarStrain = stressLogic.GetSectionStrain(strainMatrix, rebarNdm); result.RebarStress = stressLogic.GetStress(strainMatrix, rebarNdm); result.ConcreteStrain = -concreteNdm.PrestrainLogic.GetAll().Sum(x => x.PrestrainValue); @@ -94,7 +94,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking //TraceLogger?.AddMessage(LoggerStrings.CalculationError + $": {forceResult.Description}", TraceLogStatuses.Error); throw new StructureHelperException(ErrorStrings.CalculationError); } - var strain = TupleConverter.ConvertToStrainTuple(forceResult.LoaderResults.StrainMatrix); + var strain = ForceTupleConverter.ConvertToStrainTuple(forceResult.LoaderResults.StrainMatrix); return strain; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs index e6b55b2..63c72a3 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/TupleCrackCalculator.cs @@ -175,7 +175,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking TraceLogger?.AddMessage("Bearing capacity of cross-section is not enough for action", TraceLogStatuses.Error); return null; } - var strain = TupleConverter.ConvertToStrainTuple(forceResult.LoaderResults.StrainMatrix); + var strain = ForceTupleConverter.ConvertToStrainTuple(forceResult.LoaderResults.StrainMatrix); return strain; } @@ -183,7 +183,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking { lengthLogic.NdmCollection = elasticNdms; lengthLogic.TraceLogger = TraceLogger; - lengthLogic.StrainMatrix = TupleConverter.ConvertToLoaderStrainMatrix(strainTuple); + lengthLogic.StrainMatrix = ForceTupleConverter.ConvertToLoaderStrainMatrix(strainTuple); return lengthLogic.GetLength(); } diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckRebarPrimitiveLogic.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckRebarPrimitiveLogic.cs index aca5130..058d068 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckRebarPrimitiveLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckRebarPrimitiveLogic.cs @@ -1,14 +1,8 @@ using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; -using StructureHelperCommon.Models.Calculators; using StructureHelperCommon.Models.Materials; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; -namespace StructureHelperLogics.NdmCalculations.Primitives.Logics +namespace StructureHelperLogics.NdmCalculations.Primitives { public class CheckRebarPrimitiveLogic : ICheckEntityLogic { diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckPrimitiveCollectionLogic.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/HasPrimitivesCheckLogic.cs similarity index 90% rename from StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckPrimitiveCollectionLogic.cs rename to StructureHelperLogics/NdmCalculations/Primitives/Logics/HasPrimitivesCheckLogic.cs index acabea8..57506df 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckPrimitiveCollectionLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/HasPrimitivesCheckLogic.cs @@ -1,10 +1,11 @@ using StructureHelperCommon.Infrastructures.Exceptions; using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; +using StructureHelperLogics.NdmCalculations.Primitives.Logics; -namespace StructureHelperLogics.NdmCalculations.Primitives.Logics +namespace StructureHelperLogics.NdmCalculations.Primitives { - public class CheckPrimitiveCollectionLogic : ICheckEntityLogic + public class HasPrimitivesCheckLogic : ICheckEntityLogic { private const string collectionDoesntHaveAnyPrimitives = "Calculator does not contain any primitives\n"; private const string checkRebarLogic = ": check rebar logic"; @@ -19,7 +20,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics public IShiftTraceLogger? TraceLogger { get; set; } - public CheckPrimitiveCollectionLogic( + public HasPrimitivesCheckLogic( IShiftTraceLogger shiftTraceLogger, ICheckEntityLogic checkRebarPrimitiveLogic) { @@ -27,7 +28,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics this.checkRebarPrimitiveLogic = checkRebarPrimitiveLogic; } - public CheckPrimitiveCollectionLogic() : this (new ShiftTraceLogger(), new CheckRebarPrimitiveLogic()) + public HasPrimitivesCheckLogic() : this (new ShiftTraceLogger(), new CheckRebarPrimitiveLogic()) { } diff --git a/StructureHelperLogics/NdmCalculations/Triangulations/PointTriangulationLogic.cs b/StructureHelperLogics/NdmCalculations/Triangulations/PointTriangulationLogic.cs index 5d55567..cc81af9 100644 --- a/StructureHelperLogics/NdmCalculations/Triangulations/PointTriangulationLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Triangulations/PointTriangulationLogic.cs @@ -25,7 +25,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations Material = options.HeadMaterial.GetLoaderMaterial(options.TriangulationOptions.LimiteState, options.TriangulationOptions.CalcTerm) }; List ndmCollection = new () { ndm}; - NdmTransform.SetPrestrain(ndmCollection, TupleConverter.ConvertToLoaderStrainMatrix(options.Prestrain)); + NdmTransform.SetPrestrain(ndmCollection, ForceTupleConverter.ConvertToLoaderStrainMatrix(options.Prestrain)); return ndmCollection; } diff --git a/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs b/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs index a4ce3d7..230dead 100644 --- a/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs @@ -47,7 +47,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations Material = options.HeadMaterial.GetLoaderMaterial(options.TriangulationOptions.LimiteState, options.TriangulationOptions.CalcTerm) }; ; - NdmTransform.SetPrestrain(rebarNdm, TupleConverter.ConvertToLoaderStrainMatrix(options.Prestrain)); + NdmTransform.SetPrestrain(rebarNdm, ForceTupleConverter.ConvertToLoaderStrainMatrix(options.Prestrain)); return rebarNdm; } @@ -74,7 +74,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations //StressScale = -1d StressScale = 1d//-1d }; - NdmTransform.SetPrestrain(concreteNdm, TupleConverter.ConvertToLoaderStrainMatrix(prestrain)); + NdmTransform.SetPrestrain(concreteNdm, ForceTupleConverter.ConvertToLoaderStrainMatrix(prestrain)); return concreteNdm; } diff --git a/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs b/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs index 25d9435..6ddfdc3 100644 --- a/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs +++ b/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs @@ -71,7 +71,7 @@ namespace StructureHelperTests.FunctionalTests.Ndms.Calculators.ForceCalculatorT var ndmPrimitives = newSection.SectionRepository.Primitives; var result = calculator.Result as IForceCalculatorResult; var strainMatrix = result.ForcesResultList[0].ForcesTupleResult.LoaderResults.StrainMatrix; - var source = TupleConverter.ConvertToStrainTuple(strainMatrix); + var source = ForceTupleConverter.ConvertToStrainTuple(strainMatrix); //Act foreach (var item in ndmPrimitives) { diff --git a/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs b/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs index ad51f06..a07ecc7 100644 --- a/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs +++ b/StructureHelperTests/UnitTests/Ndms/CheckPrimitiveCollectionLogicTests.cs @@ -17,7 +17,7 @@ namespace StructureHelperTests.UnitTests.Ndms private Mock _mockTraceLogger; private Mock> _mockCheckRebarPrimitiveLogic; private Mock _mockHasPrimitives; - private Mock _mockCheckPrimitiveCollectionLogic; + private Mock _mockCheckPrimitiveCollectionLogic; [SetUp] public void SetUp() @@ -26,7 +26,7 @@ namespace StructureHelperTests.UnitTests.Ndms _mockCheckRebarPrimitiveLogic = new Mock>(); _mockHasPrimitives = new Mock(); - _mockCheckPrimitiveCollectionLogic = new Mock(_mockTraceLogger.Object, _mockCheckRebarPrimitiveLogic.Object) + _mockCheckPrimitiveCollectionLogic = new Mock(_mockTraceLogger.Object, _mockCheckRebarPrimitiveLogic.Object) { CallBase = true };