From 9c0122180541dca232689248ef63a45d7eac37e5 Mon Sep 17 00:00:00 2001 From: Sandeep Kumar Date: Tue, 4 Feb 2025 15:47:29 +0530 Subject: [PATCH] GSAGH-499: refactor code --- .../4_Analysis/CreateModalDynamicParameter.cs | 140 ++++-- GsaGH/Helpers/GH/InputAttributes.cs | 26 +- .../4_Analysis/GsaModalDynamicAnalysis.cs | 4 +- .../4_Analysis/CreateAnalysisTaskTests.cs | 6 +- .../CreateModalDynamicParameterTests.cs | 443 ++++++++++-------- 5 files changed, 347 insertions(+), 272 deletions(-) diff --git a/GsaGH/Components/4_Analysis/CreateModalDynamicParameter.cs b/GsaGH/Components/4_Analysis/CreateModalDynamicParameter.cs index 65ef491b7..e8cf4d88d 100644 --- a/GsaGH/Components/4_Analysis/CreateModalDynamicParameter.cs +++ b/GsaGH/Components/4_Analysis/CreateModalDynamicParameter.cs @@ -125,60 +125,102 @@ protected override void SolveInternal(IGH_DataAccess da) { da.SetData(0, new GsaModalDynamicGoo(taskParameter)); } + private bool ValidateNumberOfModeMethod(GsaModalDynamic parameter) { + var method = parameter.ModeCalculationStrategy as ModeCalculationStrategyByNumberOfModes; + if (method.NumberOfModes < 1) { + this.AddRuntimeError("Number of mode should be greater than 1"); + return false; + } + return true; + } + + private bool ValidateLowerFrequency(GsaModalDynamic parameter) { + var method = parameter.ModeCalculationStrategy as ModeCalculationStrategyByFrequency; + double higherFrequency = method.HigherFrequency ?? double.MaxValue; + if (method.LowerFrequency.HasValue && (!GsaGH.Helpers.Utility.IsInRange + (method.LowerFrequency.Value, 0, higherFrequency) || GsaGH.Helpers.Utility.IsApproxEqual(method.LowerFrequency.Value, higherFrequency))) { + this.AddRuntimeError("Lower frquency should be positive value and less than higher frquency"); + return false; + } + return true; + } + + private bool ValidateUpperFrequency(GsaModalDynamic parameter) { + var method = parameter.ModeCalculationStrategy as ModeCalculationStrategyByFrequency; + double lowerFrequency = method.LowerFrequency ?? 0; + if (method.HigherFrequency.HasValue && (!GsaGH.Helpers.Utility.IsInRange + (method.HigherFrequency.Value, lowerFrequency, method.HigherFrequency.Value) || GsaGH.Helpers.Utility.IsApproxEqual(method.HigherFrequency.Value, lowerFrequency))) { + this.AddRuntimeError("Upper frquency should be positive value and greater than lower frquency"); + return false; + } + return true; + } + + private bool ValidateFrequencyRangeMethod(GsaModalDynamic parameter) { + return ValidateLowerFrequency(parameter) && ValidateUpperFrequency(parameter); + } + + private bool ValidateTargetMassMethod(GsaModalDynamic parameter) { + var method = parameter.ModeCalculationStrategy as ModeCalculationStrategyByMassParticipation; + if (!GsaGH.Helpers.Utility.IsInRange(method.TargetMassInXDirection, 0, 100) || !GsaGH.Helpers.Utility.IsInRange(method.TargetMassInYDirection, 0, 100) || !GsaGH.Helpers.Utility.IsInRange(method.TargetMassInZDirection, 0, 100)) { + this.AddRuntimeError("Target Mass participation ratio should be within the range of [0:100]"); + return false; + } + return true; + } + + private bool ValidateMassScalefactor(GsaModalDynamic parameter) { + if (parameter.MassOption.ScaleFactor < 0) { + this.AddRuntimeError("Mass scale factor should have positive value"); + return false; + } + return true; + } + + private bool ValidateLoadScalefactor(GsaModalDynamic parameter) { + if (parameter.AdditionalMassDerivedFromLoads.ScaleFactor < 0) { + this.AddRuntimeError("Load scale factor should have positive value"); + return false; + } + return true; + } + + private bool ValidateDampingStiffness(GsaModalDynamic parameter) { + double? dampingStiffness = parameter.ModalDamping.StiffnessProportion; + if (dampingStiffness.HasValue && !GsaGH.Helpers.Utility.IsInRange(dampingStiffness.Value, 0, 1)) { + this.AddRuntimeError("Damping stiffness should be within the range [0:1]"); + return false; + } + return true; + } private bool ValidateMassParticipation(GsaModalDynamic parameter) { bool validationStatus = true; - switch (parameter.Method()) { + switch (parameter.ModeCalculationOption()) { case ModeCalculationMethod.NumberOfMode: { - var method = parameter.ModeCalculationStrategy as ModeCalculationStrategyByNumberOfModes; - if (method.NumberOfModes < 1) { - this.AddRuntimeError("Number of mode should be greater than 1"); - validationStatus = false; - } + validationStatus = ValidateNumberOfModeMethod(parameter); } break; case ModeCalculationMethod.FrquencyRange: { - var method = parameter.ModeCalculationStrategy as ModeCalculationStrategyByFrequency; - double higherFrequency = method.HigherFrequency ?? double.MaxValue; - if (method.LowerFrequency.HasValue && (!GsaGH.Helpers.Utility.IsInRange - (method.LowerFrequency.Value, 0, higherFrequency) || GsaGH.Helpers.Utility.IsApproxEqual(method.LowerFrequency.Value, higherFrequency))) { - this.AddRuntimeError("Lower frquency should be positive value and less than higher frquency"); - validationStatus = false; - } - double lowerFrequency = method.LowerFrequency ?? 0; - if (method.HigherFrequency.HasValue && (!GsaGH.Helpers.Utility.IsInRange - (method.HigherFrequency.Value, lowerFrequency, method.HigherFrequency.Value) || GsaGH.Helpers.Utility.IsApproxEqual(method.HigherFrequency.Value, lowerFrequency))) { - this.AddRuntimeError("Upper frquency should be positive value and greater than lower frquency"); - validationStatus = false; - } - + validationStatus = ValidateFrequencyRangeMethod(parameter); } break; case ModeCalculationMethod.TargetMassRatio: { - var method = parameter.ModeCalculationStrategy as ModeCalculationStrategyByMassParticipation; - if (!GsaGH.Helpers.Utility.IsInRange(method.TargetMassInXDirection, 0, 100) || !GsaGH.Helpers.Utility.IsInRange(method.TargetMassInYDirection, 0, 100) || !GsaGH.Helpers.Utility.IsInRange(method.TargetMassInZDirection, 0, 100)) { - this.AddRuntimeError("Target Mass participation ratio should be within the range of [0:100]"); - validationStatus = false; - } + validationStatus = ValidateTargetMassMethod(parameter); } break; } - double? dampingStiffness = parameter.ModalDamping.StiffnessProportion; - if (dampingStiffness.HasValue && !GsaGH.Helpers.Utility.IsInRange(dampingStiffness.Value, 0, 1)) { - this.AddRuntimeError("Damping stiffness should be within the range [0:1]"); - validationStatus = false; - } + if (!ValidateDampingStiffness(parameter)) { validationStatus = false; } - if (parameter.AdditionalMassDerivedFromLoads.ScaleFactor < 0) { - this.AddRuntimeError("Load scale factor should have positive value"); + if (!ValidateLoadScalefactor(parameter)) { validationStatus = false; } - if (parameter.MassOption.ScaleFactor < 0) { - this.AddRuntimeError("Mass scale factor should have positive value"); + if (!ValidateMassScalefactor(parameter)) { validationStatus = false; } + return validationStatus; } @@ -225,30 +267,26 @@ private void UnregisterParameters() { } public override void VariableParameterMaintenance() { - int index = 0; if (_modeMethod == ModeCalculationMethod.NumberOfMode) { - CreateParameter.Create(Params, new Param_Integer(), index++, "Modes", "Md", "Set number of mode", GH_ParamAccess.item); + CreateParameter.Create(Params, index++, new InputAttributes() { Name = "Modes", NickName = "Md", Description = "Set number of mode", Access = GH_ParamAccess.item, ParamType = new Param_Integer(), Optional = true }); } else if (_modeMethod == ModeCalculationMethod.FrquencyRange) { - CreateParameter.Create(Params, new Param_Number(), index++, "Lower frequency", "LF", "Set lower frequency range", GH_ParamAccess.item); - CreateParameter.Create(Params, new Param_Number(), index++, "Upper frequency", "UF", "Set upper frequency range", GH_ParamAccess.item); - CreateParameter.Create(Params, new Param_Integer(), index++, "Limiting modes", "LM", "Limit maximum number of mode", GH_ParamAccess.item); - + CreateParameter.Create(Params, index++, new InputAttributes() { Name = "Lower frequency", NickName = "LF", Description = "Set lower frequency range", Access = GH_ParamAccess.item, ParamType = new Param_Number(), Optional = true }); + CreateParameter.Create(Params, index++, new InputAttributes() { Name = "Upper frequency", NickName = "UF", Description = "Set upper frequency range", Access = GH_ParamAccess.item, ParamType = new Param_Number(), Optional = true }); + CreateParameter.Create(Params, index++, new InputAttributes() { Name = "Limiting modes", NickName = "LM", Description = "Limit maximum number of mode", Access = GH_ParamAccess.item, ParamType = new Param_Integer(), Optional = true }); } else { - CreateParameter.Create(Params, new Param_Number(), index++, "X-direction mass participation", "X", "Set x-direction mass participation", GH_ParamAccess.item); - CreateParameter.Create(Params, new Param_Number(), index++, "Y-direction mass participation", "Y", "Set y-direction mass participation", GH_ParamAccess.item); - CreateParameter.Create(Params, new Param_Number(), index++, "Z-direction mass participation", "Z", "Set z-direction mass participation", GH_ParamAccess.item); - CreateParameter.Create(Params, new Param_Integer(), index++, "Limiting modes", "LM", "Set limiting maximum number of mode", GH_ParamAccess.item); - CreateParameter.Create(Params, new Param_Boolean(), index++, "Skip modes with low mass participation", "MASIL", "Set the value to true to use the Masil algorithm", GH_ParamAccess.item); + CreateParameter.Create(Params, index++, new InputAttributes() { Name = "X-direction mass participation", NickName = "X", Description = "Set x-direction mass participation", Access = GH_ParamAccess.item, ParamType = new Param_Number(), Optional = true }); + CreateParameter.Create(Params, index++, new InputAttributes() { Name = "Y-direction mass participation", NickName = "Y", Description = "Set y-direction mass participation", Access = GH_ParamAccess.item, ParamType = new Param_Number(), Optional = true }); + CreateParameter.Create(Params, index++, new InputAttributes() { Name = "Z-direction mass participation", NickName = "Z", Description = "Set z-direction mass participation", Access = GH_ParamAccess.item, ParamType = new Param_Number(), Optional = true }); + CreateParameter.Create(Params, index++, new InputAttributes() { Name = "Limiting modes", NickName = "LM", Description = "Set limiting maximum number of mode", Access = GH_ParamAccess.item, ParamType = new Param_Integer(), Optional = true }); + CreateParameter.Create(Params, index++, new InputAttributes() { Name = "Skip modes with low mass participation", NickName = "MASIL", Description = "Set the value to true to use the Masil algorithm", Access = GH_ParamAccess.item, ParamType = new Param_Boolean(), Optional = true }); } - CreateParameter.Create(Params, new Param_String(), index++, "Load case ", "LC", "Additional mass load case", GH_ParamAccess.item); - CreateParameter.Create(Params, new Param_Number(), index++, "Load scale factor", "LSF", "Set load scale factor", GH_ParamAccess.item); - CreateParameter.Create(Params, new Param_Number(), index++, "Mass scale factor", "MSF", "Set mass scale factor", GH_ParamAccess.item); - CreateParameter.Create(Params, new Param_Number(), index, "Damping stiffness proportion", "DSP", "Set model damping stiffness proportion", GH_ParamAccess.item); - + CreateParameter.Create(Params, index++, new InputAttributes() { Name = "Load case", NickName = "LC", Description = "Additional mass load case", Access = GH_ParamAccess.item, ParamType = new Param_String(), Optional = true }); + CreateParameter.Create(Params, index++, new InputAttributes() { Name = "Load scale factor", NickName = "LSF", Description = "Set load scale factor", Access = GH_ParamAccess.item, ParamType = new Param_Number(), Optional = true }); + CreateParameter.Create(Params, index++, new InputAttributes() { Name = "Mass scale factor", NickName = "MSF", Description = "Set mass scale factor", Access = GH_ParamAccess.item, ParamType = new Param_Number(), Optional = true }); + CreateParameter.Create(Params, index, new InputAttributes() { Name = "Damping stiffness proportion", NickName = "DSP", Description = "Set model damping stiffness proportion", Access = GH_ParamAccess.item, ParamType = new Param_Number(), Optional = true }); } - protected override void InitialiseDropdowns() { _spacerDescriptions = new List(new[] { "Mode Strategy", diff --git a/GsaGH/Helpers/GH/InputAttributes.cs b/GsaGH/Helpers/GH/InputAttributes.cs index da67e1772..e67866a66 100644 --- a/GsaGH/Helpers/GH/InputAttributes.cs +++ b/GsaGH/Helpers/GH/InputAttributes.cs @@ -4,23 +4,23 @@ namespace GsaGH.Helpers.GH { public struct InputAttributes { - public IGH_Param ParamType; - public string NickName; - public string Name; - public string Description; - public GH_ParamAccess Access; - public bool Optional; + public string Name { get; set; } + public string NickName { get; set; } + public string Description { get; set; } + public IGH_Param ParamType { get; set; } + public GH_ParamAccess Access { get; set; } + public bool Optional { get; set; } } public static class CreateParameter { public static void Create( - GH_ComponentParamServer parameters, IGH_Param parameter, int index, string name, string nickname, string description, GH_ParamAccess access, bool optional = true) { - parameters.RegisterInputParam(parameter, index); - parameters.Input[index].Name = name; - parameters.Input[index].NickName = nickname; - parameters.Input[index].Description = description; - parameters.Input[index].Access = access; - parameters.Input[index].Optional = optional; + GH_ComponentParamServer parameters, int index, InputAttributes inputAttribute) { + parameters.RegisterInputParam(inputAttribute.ParamType, index); + parameters.Input[index].Name = inputAttribute.Name; + parameters.Input[index].NickName = inputAttribute.NickName; + parameters.Input[index].Description = inputAttribute.Description; + parameters.Input[index].Access = inputAttribute.Access; + parameters.Input[index].Optional = inputAttribute.Optional; } } } diff --git a/GsaGH/Parameters/4_Analysis/GsaModalDynamicAnalysis.cs b/GsaGH/Parameters/4_Analysis/GsaModalDynamicAnalysis.cs index 8270c7f22..10d8ccc08 100644 --- a/GsaGH/Parameters/4_Analysis/GsaModalDynamicAnalysis.cs +++ b/GsaGH/Parameters/4_Analysis/GsaModalDynamicAnalysis.cs @@ -47,7 +47,7 @@ internal GsaModalDynamic(AnalysisTask apiAnalysisTask) { } - public ModeCalculationMethod Method() { + public ModeCalculationMethod ModeCalculationOption() { if (ModeCalculationStrategy is ModeCalculationStrategyByNumberOfModes) { return ModeCalculationMethod.NumberOfMode; @@ -61,7 +61,7 @@ public ModeCalculationMethod Method() { } public override string ToString() { - return Method().ToString(); + return ModeCalculationOption().ToString(); } } diff --git a/GsaGHTests/3_Components/4_Analysis/CreateAnalysisTaskTests.cs b/GsaGHTests/3_Components/4_Analysis/CreateAnalysisTaskTests.cs index 254ad5c7d..2854d948c 100644 --- a/GsaGHTests/3_Components/4_Analysis/CreateAnalysisTaskTests.cs +++ b/GsaGHTests/3_Components/4_Analysis/CreateAnalysisTaskTests.cs @@ -56,13 +56,13 @@ public static CreateAnalysisTask CreateAnalysisTaskComponent(ModeCalculationMeth component.SetSelected(0, 3); switch (modeMethod) { case ModeCalculationMethod.NumberOfMode: - ComponentTestHelper.SetInput(component, ComponentTestHelper.GetOutput(CreateModalDynamicParameterByNumberOfModesTests.ComponentMother(ModalMassOption.MassFromElementShapeFunction, Direction.Y)), 2); + ComponentTestHelper.SetInput(component, ComponentTestHelper.GetOutput(CreateModalDynamicParameterByNumberOfModesTests.ComponentMother()), 2); break; case ModeCalculationMethod.FrquencyRange: - ComponentTestHelper.SetInput(component, ComponentTestHelper.GetOutput(CreateModalDynamicParameterByFrquencyRangeTest.ComponentMother(ModalMassOption.MassFromElementShapeFunction, Direction.Y)), 2); + ComponentTestHelper.SetInput(component, ComponentTestHelper.GetOutput(CreateModalDynamicParameterByFrquencyRangeTest.ComponentMother()), 2); break; case ModeCalculationMethod.TargetMassRatio: - ComponentTestHelper.SetInput(component, ComponentTestHelper.GetOutput(CreateModalDynamicParameterByTargetMassParticipationTest.ComponentMother(ModalMassOption.MassFromElementShapeFunction, Direction.Y)), 2); + ComponentTestHelper.SetInput(component, ComponentTestHelper.GetOutput(CreateModalDynamicParameterByTargetMassParticipationTest.ComponentMother()), 2); break; } return component; diff --git a/GsaGHTests/3_Components/4_Analysis/CreateModalDynamicParameterTests.cs b/GsaGHTests/3_Components/4_Analysis/CreateModalDynamicParameterTests.cs index 5c11a25e1..9db29595c 100644 --- a/GsaGHTests/3_Components/4_Analysis/CreateModalDynamicParameterTests.cs +++ b/GsaGHTests/3_Components/4_Analysis/CreateModalDynamicParameterTests.cs @@ -9,164 +9,271 @@ using GsaGH.Parameters; using GsaGH.Parameters.Enums; -using GsaGHTests.Components.Geometry; using GsaGHTests.Helpers; -using OasysGH.Components; - using Xunit; namespace GsaGHTests.Components.Analysis { - [Collection("GrasshopperFixture collection")] - public class CreateModalDynamicParameterByNumberOfModesTests { - private GH_OasysComponent _component; - private ModeCalculationStrategyByNumberOfModes _modeCalculationStrategy; - private GsaModalDynamic _modalDynamicAnalysis; - public CreateModalDynamicParameterByNumberOfModesTests(ModalMassOption massOption = ModalMassOption.NodalMass, Direction direction = Direction.X) { - PrepareComponent(massOption, direction); + + public class CreateModalDynamicParameterTest { + public CreateModalDynamicParameter _component; + public GsaModalDynamic _modalDynamicAnalysis; + public ModeCalculationMethod modelCalculationMethod; + internal virtual void PrepareOutPut() { } + + public void SetNumberOfMode(double value) { + ComponentTestHelper.SetInput(_component, value, 0); + PrepareOutPut(); } - private void PrepareComponent(ModalMassOption massOption, Direction direction) { - _component = ComponentMother(massOption, direction); - var _modalDynamicAnalysisGoo = (GsaModalDynamicGoo)ComponentTestHelper.GetOutput(_component); - if (_modalDynamicAnalysisGoo != null) { - _modalDynamicAnalysis = _modalDynamicAnalysisGoo.Value; - _modeCalculationStrategy = _modalDynamicAnalysis.ModeCalculationStrategy as ModeCalculationStrategyByNumberOfModes; - } + public void SetTargetMass(double x, double y, double z) { + ComponentTestHelper.SetInput(_component, x, 0); + ComponentTestHelper.SetInput(_component, y, 1); + ComponentTestHelper.SetInput(_component, z, 2); + PrepareOutPut(); } - private void SetNumberOfMode(double value) { - ComponentTestHelper.SetInput(_component, value, 0); + public void SetLimitingMode(double value) { + switch (modelCalculationMethod) { + case ModeCalculationMethod.FrquencyRange: + ComponentTestHelper.SetInput(_component, value, 2); + break; + case ModeCalculationMethod.TargetMassRatio: + ComponentTestHelper.SetInput(_component, value, 3); + break; + default: + break; + } + PrepareOutPut(); } - private void SetStiffness(double value) { - ComponentTestHelper.SetInput(_component, value, 4); + public void SetDampingStiffness(double value) { + switch (modelCalculationMethod) { + case ModeCalculationMethod.NumberOfMode: + ComponentTestHelper.SetInput(_component, value, 4); + break; + case ModeCalculationMethod.FrquencyRange: + ComponentTestHelper.SetInput(_component, value, 6); + break; + case ModeCalculationMethod.TargetMassRatio: + ComponentTestHelper.SetInput(_component, value, 8); + break; + default: + break; + } + PrepareOutPut(); } - private void SetScaleFactor(double loadScaleFactor, double massScalefactor) { - ComponentTestHelper.SetInput(_component, loadScaleFactor, 2); - ComponentTestHelper.SetInput(_component, massScalefactor, 3); + public void SetLoadScaleFactor(double loadScaleFactor) { + switch (modelCalculationMethod) { + case ModeCalculationMethod.NumberOfMode: + ComponentTestHelper.SetInput(_component, loadScaleFactor, 2); + break; + case ModeCalculationMethod.FrquencyRange: + ComponentTestHelper.SetInput(_component, loadScaleFactor, 4); + break; + case ModeCalculationMethod.TargetMassRatio: + ComponentTestHelper.SetInput(_component, loadScaleFactor, 6); + break; + default: + break; + } + PrepareOutPut(); } - public static GH_OasysComponent ComponentMother(ModalMassOption massOption, Direction direction) { - var comp = new CreateModalDynamicParameter(); - comp.CreateAttributes(); - comp.SetSelected(0, 0); - int index = 0; - ComponentTestHelper.SetInput(comp, 5, index++); - ComponentTestHelper.SetInput(comp, "L1", index++); - ComponentTestHelper.SetInput(comp, 1.1, index++); - ComponentTestHelper.SetInput(comp, 1.2, index++); - ComponentTestHelper.SetInput(comp, 1, index); + public void SetMassScaleFactor(double massScalefactor) { + switch (modelCalculationMethod) { + case ModeCalculationMethod.NumberOfMode: + ComponentTestHelper.SetInput(_component, massScalefactor, 3); + break; + case ModeCalculationMethod.FrquencyRange: + ComponentTestHelper.SetInput(_component, massScalefactor, 5); + break; + case ModeCalculationMethod.TargetMassRatio: + ComponentTestHelper.SetInput(_component, massScalefactor, 7); + break; + default: + break; + } + PrepareOutPut(); + } - switch (massOption) { - case ModalMassOption.LumpMassAtNode: - comp.SetSelected(1, 0); + public void SetLoadCase(string loadCase) { + switch (modelCalculationMethod) { + case ModeCalculationMethod.NumberOfMode: + ComponentTestHelper.SetInput(_component, loadCase, 1); break; - case ModalMassOption.MassFromElementShapeFunction: - comp.SetSelected(1, 1); + case ModeCalculationMethod.FrquencyRange: + ComponentTestHelper.SetInput(_component, loadCase, 3); break; - case ModalMassOption.NodalMass: - comp.SetSelected(1, 2); + case ModeCalculationMethod.TargetMassRatio: + ComponentTestHelper.SetInput(_component, loadCase, 5); break; default: break; } + PrepareOutPut(); + } + public void SetMasil(bool value) { + ComponentTestHelper.SetInput(_component, value, 4); + PrepareOutPut(); + } + + public void SetFrequency(double lower, double upper) { + ComponentTestHelper.SetInput(_component, lower, 0); + ComponentTestHelper.SetInput(_component, upper, 1); + PrepareOutPut(); + } + + public void SetDirection(Direction direction) { switch (direction) { case Direction.X: - comp.SetSelected(2, 0); + _component.SetSelected(2, 0); break; case Direction.Y: - comp.SetSelected(2, 1); + _component.SetSelected(2, 1); break; case Direction.Z: - comp.SetSelected(2, 2); + _component.SetSelected(2, 2); break; default: break; } + PrepareOutPut(); + } + + public void SetMassOption(ModalMassOption massOption) { + switch (massOption) { + case ModalMassOption.LumpMassAtNode: + _component.SetSelected(1, 0); + break; + case ModalMassOption.MassFromElementShapeFunction: + _component.SetSelected(1, 1); + break; + case ModalMassOption.NodalMass: + _component.SetSelected(1, 2); + break; + default: + break; + } + PrepareOutPut(); + } + + } + + [Collection("GrasshopperFixture collection")] + public class CreateModalDynamicParameterByNumberOfModesTests : CreateModalDynamicParameterTest { + public ModeCalculationStrategyByNumberOfModes _modeCalculationStrategy; + + public CreateModalDynamicParameterByNumberOfModesTests() { + _component = ComponentMother(); + modelCalculationMethod = ModeCalculationMethod.NumberOfMode; + } + + internal override void PrepareOutPut() { + var _modalDynamicAnalysisGoo = (GsaModalDynamicGoo)ComponentTestHelper.GetOutput(_component); + if (_modalDynamicAnalysisGoo != null) { + _modalDynamicAnalysis = _modalDynamicAnalysisGoo.Value; + _modeCalculationStrategy = _modalDynamicAnalysis.ModeCalculationStrategy as ModeCalculationStrategyByNumberOfModes; + } + } + + public static CreateModalDynamicParameter ComponentMother() { + var comp = new CreateModalDynamicParameter(); + comp.CreateAttributes(); + comp.SetSelected(0, 0); return comp; } [Fact] public void ComponentShouldReturnCorrectNumberOfMode() { + SetNumberOfMode(5); Assert.Equal(5, _modeCalculationStrategy.NumberOfModes); } [Fact] public void ComponentShouldReportErrorWhenNumberOfModeIsNegativeValue() { SetNumberOfMode(-1); - ComponentTestHelper.ComputeOutput(_component); Assert.Single(_component.RuntimeMessages(GH_RuntimeMessageLevel.Error)); } [Fact] public void ComponentShouldReportErrorWhenStiffnessIsNotInRange() { - SetStiffness(2); - ComponentTestHelper.ComputeOutput(_component); + SetDampingStiffness(2); Assert.Single(_component.RuntimeMessages(GH_RuntimeMessageLevel.Error)); } [Fact] - public void ComponentShouldReportErrorWhenScaleFactorsAreNegative() { - SetScaleFactor(-1,-2); - ComponentTestHelper.ComputeOutput(_component); - Assert.Equal(2,_component.RuntimeMessages(GH_RuntimeMessageLevel.Error).Count); + public void ComponentShouldReportErrorWhenLoadScaleFactorsAreNegative() { + SetLoadScaleFactor(-1); + Assert.Single(_component.RuntimeMessages(GH_RuntimeMessageLevel.Error)); + } + + [Fact] + public void ComponentShouldReportErrorWhenMassScaleFactorsAreNegative() { + SetMassScaleFactor(-1); + Assert.Single(_component.RuntimeMessages(GH_RuntimeMessageLevel.Error)); } [Fact] public void ComponentShouldReturnCorrectCaseDefinition() { + SetLoadCase("L1"); Assert.Equal("L1", _modalDynamicAnalysis.AdditionalMassDerivedFromLoads.CaseDefinition); } [Fact] public void ComponentShouldReturnCorrectLoadScaleFactor() { + SetLoadScaleFactor(1.1); Assert.Equal(1.1, _modalDynamicAnalysis.AdditionalMassDerivedFromLoads.ScaleFactor); } [Fact] public void ComponentShouldReturnCorrectMassScaleFactor() { + SetMassScaleFactor(1.2); Assert.Equal(1.2, _modalDynamicAnalysis.MassOption.ScaleFactor); } [Fact] public void ComponentShouldReturnCorrectStiffnessProportion() { + SetDampingStiffness(1); Assert.Equal(1, _modalDynamicAnalysis.ModalDamping.StiffnessProportion); } - [Fact] - public void ComponentShouldReturnCorrectNodalMassOption() { - Assert.Equal(ModalMassOption.NodalMass, _modalDynamicAnalysis.MassOption.ModalMassOption); - } - [Fact] public void ComponentShouldReturnCorrectXDirecion() { + SetDirection(Direction.X); Assert.Equal(Direction.X, _modalDynamicAnalysis.AdditionalMassDerivedFromLoads.Direction); } [Fact] public void ComponentShouldReturnCorrectYDirecion() { - PrepareComponent(ModalMassOption.NodalMass, Direction.Y); + SetDirection(Direction.Y); Assert.Equal(Direction.Y, _modalDynamicAnalysis.AdditionalMassDerivedFromLoads.Direction); } [Fact] public void ComponentShouldReturnCorrectZDirecion() { - PrepareComponent(ModalMassOption.NodalMass, Direction.Z); + SetDirection(Direction.Z); Assert.Equal(Direction.Z, _modalDynamicAnalysis.AdditionalMassDerivedFromLoads.Direction); } + [Fact] + public void ComponentShouldReturnCorrectNodalMassOption() { + SetMassOption(ModalMassOption.NodalMass); + Assert.Equal(ModalMassOption.NodalMass, _modalDynamicAnalysis.MassOption.ModalMassOption); + } + [Fact] public void ComponentShouldReturnCorrectLumpMassOption() { - PrepareComponent(ModalMassOption.LumpMassAtNode, Direction.Y); + SetMassOption(ModalMassOption.LumpMassAtNode); Assert.Equal(ModalMassOption.LumpMassAtNode, _modalDynamicAnalysis.MassOption.ModalMassOption); } [Fact] public void ComponentShouldReturnCorrectElementShapeFunctionOption() { - PrepareComponent(ModalMassOption.MassFromElementShapeFunction, Direction.Z); + SetMassOption(ModalMassOption.MassFromElementShapeFunction); Assert.Equal(ModalMassOption.MassFromElementShapeFunction, _modalDynamicAnalysis.MassOption.ModalMassOption); } @@ -175,23 +282,20 @@ public void ModalDynamicCreatedFromTaskReturnCorrectMethod() { CreateAnalysisTask analysisTaskComponent = CreateAnalysisTaskTests.CreateAnalysisTaskComponent(ModeCalculationMethod.NumberOfMode); GsaAnalysisTask task = ((GsaAnalysisTaskGoo)ComponentTestHelper.GetOutput(analysisTaskComponent)).Value; var modaldynamic = new GsaModalDynamic(task.ApiTask); - Assert.Equal(ModeCalculationMethod.NumberOfMode, modaldynamic.Method()); + Assert.Equal(ModeCalculationMethod.NumberOfMode, modaldynamic.ModeCalculationOption()); } } [Collection("GrasshopperFixture collection")] - public class CreateModalDynamicParameterByFrquencyRangeTest { - private GH_OasysComponent _component; + public class CreateModalDynamicParameterByFrquencyRangeTest : CreateModalDynamicParameterTest { private ModeCalculationStrategyByFrequency _modeCalculationStrategy; - private GsaModalDynamic _modalDynamicAnalysis; - public CreateModalDynamicParameterByFrquencyRangeTest(ModalMassOption massOption = ModalMassOption.NodalMass, Direction direction = Direction.X) { - PrepareComponent(massOption, direction); + public CreateModalDynamicParameterByFrquencyRangeTest() { + _component = ComponentMother(); + modelCalculationMethod = ModeCalculationMethod.FrquencyRange; } - - private void PrepareComponent(ModalMassOption massOption, Direction direction) { - _component = ComponentMother(massOption, direction); + internal override void PrepareOutPut() { var _modalDynamicAnalysisGoo = (GsaModalDynamicGoo)ComponentTestHelper.GetOutput(_component); if (_modalDynamicAnalysisGoo != null) { _modalDynamicAnalysis = _modalDynamicAnalysisGoo.Value; @@ -199,127 +303,94 @@ private void PrepareComponent(ModalMassOption massOption, Direction direction) { } } - private void SetFrequency(double lower, double upper) { - ComponentTestHelper.SetInput(_component, lower, 0); - ComponentTestHelper.SetInput(_component, upper, 1); - } - - public static GH_OasysComponent ComponentMother(ModalMassOption massOption = ModalMassOption.LumpMassAtNode, Direction direction = Direction.Y) { + public static CreateModalDynamicParameter ComponentMother() { var comp = new CreateModalDynamicParameter(); comp.CreateAttributes(); comp.SetSelected(0, 1); - int index = 0; - ComponentTestHelper.SetInput(comp, 5, index++); - ComponentTestHelper.SetInput(comp, 10, index++); - ComponentTestHelper.SetInput(comp, 30, index++); - ComponentTestHelper.SetInput(comp, "L1", index++); - ComponentTestHelper.SetInput(comp, 1.1, index++); - ComponentTestHelper.SetInput(comp, 1.2, index++); - ComponentTestHelper.SetInput(comp, 1, index); - - switch (massOption) { - case ModalMassOption.LumpMassAtNode: - comp.SetSelected(1, 0); - break; - case ModalMassOption.MassFromElementShapeFunction: - comp.SetSelected(1, 1); - break; - case ModalMassOption.NodalMass: - comp.SetSelected(1, 2); - break; - default: - break; - } - - switch (direction) { - case Direction.X: - comp.SetSelected(2, 0); - break; - case Direction.Y: - comp.SetSelected(2, 1); - break; - case Direction.Z: - comp.SetSelected(2, 2); - break; - default: - break; - } return comp; } [Fact] public void ComponentShouldReturnCorrectNumberOfLimitingMode() { + SetLimitingMode(30); Assert.Equal(30, _modeCalculationStrategy.MaximumNumberOfModes); } + [Fact] + public void ComponentShouldReturnCorrectLowerFrequency() { + SetFrequency(5, 10); + Assert.Equal(5, _modeCalculationStrategy.LowerFrequency); + } + [Fact] public void ComponentShouldReturnCorrectUpperFrequency() { + SetFrequency(0, 10); Assert.Equal(10, _modeCalculationStrategy.HigherFrequency); } [Fact] public void ComponentShouldReportErrorIfFrequenciesAreNotCorrect() { SetFrequency(6, 5); - ComponentTestHelper.ComputeOutput(_component); - Assert.Equal(2, _component.RuntimeMessages(GH_RuntimeMessageLevel.Error).Count); - } - - [Fact] - public void ComponentShouldReturnCorrectLowerFrequency() { - Assert.Equal(5, _modeCalculationStrategy.LowerFrequency); + Assert.Single(_component.RuntimeMessages(GH_RuntimeMessageLevel.Error)); } [Fact] public void ComponentShouldReturnCorrectCaseDefinition() { + SetLoadCase("L1"); Assert.Equal("L1", _modalDynamicAnalysis.AdditionalMassDerivedFromLoads.CaseDefinition); } [Fact] public void ComponentShouldReturnCorrectLoadScaleFactor() { + SetLoadScaleFactor(1.1); Assert.Equal(1.1, _modalDynamicAnalysis.AdditionalMassDerivedFromLoads.ScaleFactor); } [Fact] public void ComponentShouldReturnCorrectMassScaleFactor() { + SetMassScaleFactor(1.2); Assert.Equal(1.2, _modalDynamicAnalysis.MassOption.ScaleFactor); } [Fact] public void ComponentShouldReturnCorrectStiffnessProportion() { + SetDampingStiffness(1); Assert.Equal(1, _modalDynamicAnalysis.ModalDamping.StiffnessProportion); } - [Fact] - public void ComponentShouldReturnCorrectNodalMassOption() { - Assert.Equal(ModalMassOption.NodalMass, _modalDynamicAnalysis.MassOption.ModalMassOption); - } - [Fact] public void ComponentShouldReturnCorrectXDirecion() { + SetDirection(Direction.X); Assert.Equal(Direction.X, _modalDynamicAnalysis.AdditionalMassDerivedFromLoads.Direction); } [Fact] public void ComponentShouldReturnCorrectYDirecion() { - PrepareComponent(ModalMassOption.NodalMass, Direction.Y); + SetDirection(Direction.Y); Assert.Equal(Direction.Y, _modalDynamicAnalysis.AdditionalMassDerivedFromLoads.Direction); } [Fact] public void ComponentShouldReturnCorrectZDirecion() { - PrepareComponent(ModalMassOption.NodalMass, Direction.Z); + SetDirection(Direction.Z); Assert.Equal(Direction.Z, _modalDynamicAnalysis.AdditionalMassDerivedFromLoads.Direction); } + [Fact] + public void ComponentShouldReturnCorrectNodalMassOption() { + SetMassOption(ModalMassOption.NodalMass); + Assert.Equal(ModalMassOption.NodalMass, _modalDynamicAnalysis.MassOption.ModalMassOption); + } + [Fact] public void ComponentShouldReturnCorrectLumpMassOption() { - PrepareComponent(ModalMassOption.LumpMassAtNode, Direction.Y); + SetMassOption(ModalMassOption.LumpMassAtNode); Assert.Equal(ModalMassOption.LumpMassAtNode, _modalDynamicAnalysis.MassOption.ModalMassOption); } [Fact] public void ComponentShouldReturnCorrectElementShapeFunctionOption() { - PrepareComponent(ModalMassOption.MassFromElementShapeFunction, Direction.Z); + SetMassOption(ModalMassOption.MassFromElementShapeFunction); Assert.Equal(ModalMassOption.MassFromElementShapeFunction, _modalDynamicAnalysis.MassOption.ModalMassOption); } @@ -328,27 +399,20 @@ public void ModalDynamicCreatedFromTaskReturnCorrectMethod() { CreateAnalysisTask analysisTaskComponent = CreateAnalysisTaskTests.CreateAnalysisTaskComponent(ModeCalculationMethod.FrquencyRange); GsaAnalysisTask task = ((GsaAnalysisTaskGoo)ComponentTestHelper.GetOutput(analysisTaskComponent)).Value; var modaldynamic = new GsaModalDynamic(task.ApiTask); - Assert.Equal(ModeCalculationMethod.FrquencyRange, modaldynamic.Method()); + Assert.Equal(ModeCalculationMethod.FrquencyRange, modaldynamic.ModeCalculationOption()); } } [Collection("GrasshopperFixture collection")] - public class CreateModalDynamicParameterByTargetMassParticipationTest { - private GH_OasysComponent _component; + public class CreateModalDynamicParameterByTargetMassParticipationTest : CreateModalDynamicParameterTest { private ModeCalculationStrategyByMassParticipation _modeCalculationStrategy; - private GsaModalDynamic _modalDynamicAnalysis; - public CreateModalDynamicParameterByTargetMassParticipationTest(ModalMassOption massOption = ModalMassOption.NodalMass, Direction direction = Direction.X) { - PrepareComponent(massOption, direction); + public CreateModalDynamicParameterByTargetMassParticipationTest() { + _component = ComponentMother(); + modelCalculationMethod = ModeCalculationMethod.TargetMassRatio; } - private void SetTargetMas(double x, double y, double z) { - ComponentTestHelper.SetInput(_component, x, 0); - ComponentTestHelper.SetInput(_component, y, 1); - ComponentTestHelper.SetInput(_component, z, 2); - } - private void PrepareComponent(ModalMassOption massOption, Direction direction) { - _component = ComponentMother(massOption, direction); + internal override void PrepareOutPut() { var _modalDynamicAnalysisGoo = (GsaModalDynamicGoo)ComponentTestHelper.GetOutput(_component); if (_modalDynamicAnalysisGoo != null) { _modalDynamicAnalysis = _modalDynamicAnalysisGoo.Value; @@ -356,169 +420,142 @@ private void PrepareComponent(ModalMassOption massOption, Direction direction) { } } - public static GH_OasysComponent ComponentMother(ModalMassOption massOption, Direction direction) { + public static CreateModalDynamicParameter ComponentMother() { var comp = new CreateModalDynamicParameter(); comp.CreateAttributes(); comp.SetSelected(0, 2); - int index = 0; - ComponentTestHelper.SetInput(comp, 90, index++); - ComponentTestHelper.SetInput(comp, 95, index++); - ComponentTestHelper.SetInput(comp, 100, index++); - ComponentTestHelper.SetInput(comp, 10, index++); - ComponentTestHelper.SetInput(comp, true, index++); - ComponentTestHelper.SetInput(comp, "L1", index++); - ComponentTestHelper.SetInput(comp, 1.1, index++); - ComponentTestHelper.SetInput(comp, 1.2, index++); - ComponentTestHelper.SetInput(comp, 1, index); - - switch (massOption) { - case ModalMassOption.LumpMassAtNode: - comp.SetSelected(1, 0); - break; - case ModalMassOption.MassFromElementShapeFunction: - comp.SetSelected(1, 1); - break; - case ModalMassOption.NodalMass: - comp.SetSelected(1, 2); - break; - default: - break; - } - - switch (direction) { - case Direction.X: - comp.SetSelected(2, 0); - break; - case Direction.Y: - comp.SetSelected(2, 1); - break; - case Direction.Z: - comp.SetSelected(2, 2); - break; - default: - break; - } return comp; } [Fact] public void ComponentShouldReportErrorIfTargetMassFactorLessThanZeroInXDirection() { - SetTargetMas(-1, 100, 100); - ComponentTestHelper.ComputeOutput(_component); + SetTargetMass(-1, 100, 100); Assert.Single(_component.RuntimeMessages(GH_RuntimeMessageLevel.Error)); } [Fact] public void ComponentShouldReportErrorIfTargetMassFactorGreaterThan100InXDirection() { - SetTargetMas(101, 100, 100); - ComponentTestHelper.ComputeOutput(_component); + SetTargetMass(101, 100, 100); Assert.Single(_component.RuntimeMessages(GH_RuntimeMessageLevel.Error)); } [Fact] public void ComponentShouldReportErrorIfTargetMassFactorLessThanZeroInYDirection() { - SetTargetMas(100, -1, 100); - ComponentTestHelper.ComputeOutput(_component); + SetTargetMass(100, -1, 100); Assert.Single(_component.RuntimeMessages(GH_RuntimeMessageLevel.Error)); } [Fact] public void ComponentShouldReportErrorIfTargetMassFactorGreaterThan100InYDirection() { - SetTargetMas(100, 101, 100); - ComponentTestHelper.ComputeOutput(_component); + SetTargetMass(100, 101, 100); Assert.Single(_component.RuntimeMessages(GH_RuntimeMessageLevel.Error)); } [Fact] public void ComponentShouldReportErrorIfTargetMassFactorLessThanZeroInZDirection() { - SetTargetMas(100, 100, -1); - ComponentTestHelper.ComputeOutput(_component); + SetTargetMass(100, 100, -1); Assert.Single(_component.RuntimeMessages(GH_RuntimeMessageLevel.Error)); } [Fact] public void ComponentShouldReportErrorIfTargetMassFactorGreaterThan100InZDirection() { - SetTargetMas(100, 100, 101); - ComponentTestHelper.ComputeOutput(_component); + SetTargetMass(100, 100, 101); Assert.Single(_component.RuntimeMessages(GH_RuntimeMessageLevel.Error)); } [Fact] public void ComponentShouldReturnCorrectXDirectionParticipation() { + SetTargetMass(90, 100, 100); Assert.Equal(90, _modeCalculationStrategy.TargetMassInXDirection); } [Fact] public void ComponentShouldReturnCorrectYDirectionParticipation() { + SetTargetMass(90, 95, 100); Assert.Equal(95, _modeCalculationStrategy.TargetMassInYDirection); } [Fact] public void ComponentShouldReturnCorrectZDirectionParticipation() { - Assert.Equal(100, _modeCalculationStrategy.TargetMassInZDirection); + SetTargetMass(90, 100, 99); + Assert.Equal(99, _modeCalculationStrategy.TargetMassInZDirection); } [Fact] public void ComponentShouldReturnCorrectNumberOfLimitingMode() { + SetLimitingMode(10); Assert.Equal(10, _modeCalculationStrategy.MaximumNumberOfModes); } [Fact] - public void ComponentShouldReturnCorrectMASILOption() { + public void ComponentShouldReturnMASILOptionTrue() { + SetMasil(true); Assert.True(_modeCalculationStrategy.SkipModesWithLowMassParticipation); } + [Fact] + public void ComponentShouldReturnMASILOptionFalse() { + SetMasil(false); + Assert.False(_modeCalculationStrategy.SkipModesWithLowMassParticipation); + } + [Fact] public void ComponentShouldReturnCorrectCaseDefinition() { + SetLoadCase("L1"); Assert.Equal("L1", _modalDynamicAnalysis.AdditionalMassDerivedFromLoads.CaseDefinition); } [Fact] public void ComponentShouldReturnCorrectLoadScaleFactor() { + SetLoadScaleFactor(1.1); Assert.Equal(1.1, _modalDynamicAnalysis.AdditionalMassDerivedFromLoads.ScaleFactor); } [Fact] public void ComponentShouldReturnCorrectMassScaleFactor() { + SetMassScaleFactor(1.2); Assert.Equal(1.2, _modalDynamicAnalysis.MassOption.ScaleFactor); } [Fact] public void ComponentShouldReturnCorrectStiffnessProportion() { + SetDampingStiffness(1); Assert.Equal(1, _modalDynamicAnalysis.ModalDamping.StiffnessProportion); } - [Fact] - public void ComponentShouldReturnCorrectNodalMassOption() { - Assert.Equal(ModalMassOption.NodalMass, _modalDynamicAnalysis.MassOption.ModalMassOption); - } - [Fact] public void ComponentShouldReturnCorrectXDirecion() { + SetDirection(Direction.X); Assert.Equal(Direction.X, _modalDynamicAnalysis.AdditionalMassDerivedFromLoads.Direction); } [Fact] public void ComponentShouldReturnCorrectYDirecion() { - PrepareComponent(ModalMassOption.NodalMass, Direction.Y); + SetDirection(Direction.Y); Assert.Equal(Direction.Y, _modalDynamicAnalysis.AdditionalMassDerivedFromLoads.Direction); } [Fact] public void ComponentShouldReturnCorrectZDirecion() { - PrepareComponent(ModalMassOption.NodalMass, Direction.Z); + SetDirection(Direction.Z); Assert.Equal(Direction.Z, _modalDynamicAnalysis.AdditionalMassDerivedFromLoads.Direction); } + [Fact] + public void ComponentShouldReturnCorrectNodalMassOption() { + SetMassOption(ModalMassOption.NodalMass); + Assert.Equal(ModalMassOption.NodalMass, _modalDynamicAnalysis.MassOption.ModalMassOption); + } + [Fact] public void ComponentShouldReturnCorrectLumpMassOption() { - PrepareComponent(ModalMassOption.LumpMassAtNode, Direction.Y); + SetMassOption(ModalMassOption.LumpMassAtNode); Assert.Equal(ModalMassOption.LumpMassAtNode, _modalDynamicAnalysis.MassOption.ModalMassOption); } [Fact] public void ComponentShouldReturnCorrectElementShapeFunctionOption() { - PrepareComponent(ModalMassOption.MassFromElementShapeFunction, Direction.Z); + SetMassOption(ModalMassOption.MassFromElementShapeFunction); Assert.Equal(ModalMassOption.MassFromElementShapeFunction, _modalDynamicAnalysis.MassOption.ModalMassOption); } @@ -527,7 +564,7 @@ public void ModalDynamicCreatedFromTaskReturnCorrectMethod() { CreateAnalysisTask analysisTaskComponent = CreateAnalysisTaskTests.CreateAnalysisTaskComponent(ModeCalculationMethod.TargetMassRatio); GsaAnalysisTask task = ((GsaAnalysisTaskGoo)ComponentTestHelper.GetOutput(analysisTaskComponent)).Value; var modaldynamic = new GsaModalDynamic(task.ApiTask); - Assert.Equal(ModeCalculationMethod.TargetMassRatio, modaldynamic.Method()); + Assert.Equal(ModeCalculationMethod.TargetMassRatio, modaldynamic.ModeCalculationOption()); } }