diff --git a/Robot_Adapter/CRUD/Create/Elements/Bars.cs b/Robot_Adapter/CRUD/Create/Elements/Bars.cs index 654ca6e3..69da0900 100644 --- a/Robot_Adapter/CRUD/Create/Elements/Bars.cs +++ b/Robot_Adapter/CRUD/Create/Elements/Bars.cs @@ -57,6 +57,55 @@ private bool CreateCollection(IEnumerable bhomBars) int barNum = 0; Dictionary> barTags = GetTypeTags(typeof(Bar)); + // First pass: handle existing bars with FramingElementDesignProperties + List existingBarsWithProperties = new List(); + foreach (Bar bhomBar in bars) + { + if (!CheckInputObjectAndExtractAdapterIdInt(bhomBar, out barNum, EventType.Error)) + continue; + + if (barServer.Exist(barNum) > 0) + { + IFragment designFragment; + if (bhomBar.Fragments.TryGetValue(typeof(FramingElementDesignProperties), out designFragment)) + { + FramingElementDesignProperties framEleDesProps = designFragment as FramingElementDesignProperties; + if (framEleDesProps != null) + { + existingBarsWithProperties.Add(bhomBar); + } + } + } + } + + // Process existing bars with properties separately to avoid cache conflicts + foreach (Bar bhomBar in existingBarsWithProperties) + { + if (!CheckInputObjectAndExtractAdapterIdInt(bhomBar, out barNum, EventType.Error)) + continue; + + RobotBar existingBar = barServer.Get(barNum) as RobotBar; + if (existingBar != null) + { + IFragment designFragment; + if (bhomBar.Fragments.TryGetValue(typeof(FramingElementDesignProperties), out designFragment)) + { + FramingElementDesignProperties framEleDesProps = designFragment as FramingElementDesignProperties; + if (framEleDesProps != null) + { + // Ensure the properties definition exists in Robot + if (m_RobotApplication.Project.Structure.Labels.Exist(IRobotLabelType.I_LT_MEMBER_TYPE, framEleDesProps.Name) == 0) + { + Create(framEleDesProps); + } + // Assign the properties to the bar + existingBar.SetLabel(IRobotLabelType.I_LT_MEMBER_TYPE, framEleDesProps.Name); + } + } + } + } + + // Second pass: handle new bars through cache system List nonCacheBars = new List(); foreach (Bar bhomBar in bars) { @@ -64,6 +113,10 @@ private bool CreateCollection(IEnumerable bhomBars) if (!CheckInputObjectAndExtractAdapterIdInt(bhomBar, out barNum, EventType.Error)) continue; + // Skip bars that already exist (already processed above) + if (barServer.Exist(barNum) > 0) + continue; + int stNodeId, endNodeId; //Check nodes are not null and correctly set up and extract id information @@ -122,16 +175,12 @@ private bool CreateCollection(IEnumerable bhomBars) FramingElementDesignProperties framEleDesProps = designFragment as FramingElementDesignProperties; if (framEleDesProps != null) { - if (m_RobotApplication.Project.Structure.Labels.Exist(IRobotLabelType.I_LT_MEMBER_TYPE, framEleDesProps.Name) != -1) + if (m_RobotApplication.Project.Structure.Labels.Exist(IRobotLabelType.I_LT_MEMBER_TYPE, framEleDesProps.Name) == 0) { Create(framEleDesProps); } - else - { - List framEleDesPropsList = new List(); - framEleDesPropsList.Add(framEleDesProps); - Update(framEleDesPropsList); - } + // If the FramingElementDesignProperties already exists, just assign it to the bar + // No need to update the properties themselves when they're attached as fragments rcache.SetBarLabel(barNum, IRobotLabelType.I_LT_MEMBER_TYPE, framEleDesProps.Name); } } diff --git a/Robot_Adapter/CRUD/Create/Properties/FramingElementDesignProperties.cs b/Robot_Adapter/CRUD/Create/Properties/FramingElementDesignProperties.cs index 59d0ac25..6da4357a 100644 --- a/Robot_Adapter/CRUD/Create/Properties/FramingElementDesignProperties.cs +++ b/Robot_Adapter/CRUD/Create/Properties/FramingElementDesignProperties.cs @@ -42,52 +42,8 @@ private bool Create(FramingElementDesignProperties framEleDesProps) //TODO: move IRobotLabelServer labelServer = m_RobotApplication.Project.Structure.Labels; IRobotLabel label = labelServer.CreateLike(IRobotLabelType.I_LT_MEMBER_TYPE, framEleDesProps.Name, labelServer.GetDefault(IRobotLabelType.I_LT_MEMBER_TYPE)); - IRDimMembDef memberDef = label.Data; - - if (framEleDesProps.MemberLengthYIsRelative) - memberDef.SetLengthYZUV(IRDimMembDefLengthDataType.I_DMDLDT_LENGTH_Y, -framEleDesProps.MemberLengthY); - else - memberDef.SetLengthYZUV(IRDimMembDefLengthDataType.I_DMDLDT_LENGTH_Y, framEleDesProps.MemberLengthY); - - if (framEleDesProps.MemberLengthZIsRelative) - memberDef.SetLengthYZUV(IRDimMembDefLengthDataType.I_DMDLDT_LENGTH_Z, -framEleDesProps.MemberLengthZ); - else - memberDef.SetLengthYZUV(IRDimMembDefLengthDataType.I_DMDLDT_LENGTH_Z, framEleDesProps.MemberLengthZ); - - - string steelMembersCodeType = m_RobotApplication.Project.Preferences.GetActiveCode(IRobotCodeType.I_CT_STEEL_STRUCTURES); - - if (steelMembersCodeType == BHE.Query.GetStringFromEnum(DesignCode_Steel.BS_EN_1993_1_2005_NA_2008_A1_2014)) - { - IRDimMembParamsE32 memberDesignParams_EC3 = memberDef.CodeParams; - memberDesignParams_EC3.BuckLengthCoeffY = framEleDesProps.EulerBucklingLengthCoefficientY; - memberDesignParams_EC3.BuckLengthCoeffZ = framEleDesProps.EulerBucklingLengthCoefficientZ; - memberDef.CodeParams = memberDesignParams_EC3; - } - - if (steelMembersCodeType == BHE.Query.GetStringFromEnum(DesignCode_Steel.BS5950)) - { - IRDimMembParamsBS59 memberDesignParams_BS5950 = memberDef.CodeParams; - memberDesignParams_BS5950.BuckLengthCoeffY = framEleDesProps.EulerBucklingLengthCoefficientY; - memberDesignParams_BS5950.BuckLengthCoeffZ = framEleDesProps.EulerBucklingLengthCoefficientZ; - memberDef.CodeParams = memberDesignParams_BS5950; - } - - if (steelMembersCodeType == BHE.Query.GetStringFromEnum(DesignCode_Steel.BS5950_2000)) - { - IRDimMembParamsBS59_2000 memberDesignParams_BS5950_2000 = memberDef.CodeParams; - memberDesignParams_BS5950_2000.BuckLengthCoeffY = framEleDesProps.EulerBucklingLengthCoefficientY; - memberDesignParams_BS5950_2000.BuckLengthCoeffZ = framEleDesProps.EulerBucklingLengthCoefficientZ; - memberDef.CodeParams = memberDesignParams_BS5950_2000; - } - - if (steelMembersCodeType == BHE.Query.GetStringFromEnum(DesignCode_Steel.ANSI_AISC_360_10)) - { - IRDimMembParamsANS memberDesignParams_AISC_360_10 = memberDef.CodeParams; - memberDesignParams_AISC_360_10.BuckLenghtCoeffY = framEleDesProps.EulerBucklingLengthCoefficientY; - memberDesignParams_AISC_360_10.BuckLenghtCoeffZ = framEleDesProps.EulerBucklingLengthCoefficientZ; - memberDef.CodeParams = memberDesignParams_AISC_360_10; - } + // Use the ToRobot method with the configured design code + Convert.ToRobot(label, framEleDesProps, RobotConfig.DatabaseSettings.SteelDesignCode); labelServer.Store(label); @@ -109,6 +65,9 @@ private bool CreateCollection(IEnumerable framEl IRobotLabel label = labelServer.CreateLike(IRobotLabelType.I_LT_MEMBER_TYPE, framEleDesProps.Name, labelServer.GetDefault(IRobotLabelType.I_LT_MEMBER_TYPE)); + // Use the ToRobot method with the configured design code + Convert.ToRobot(label, framEleDesProps, RobotConfig.DatabaseSettings.SteelDesignCode); + labelServer.Store(label); } return true; diff --git a/Robot_Adapter/CRUD/Read/Properties/FramingElementDesignProperties.cs b/Robot_Adapter/CRUD/Read/Properties/FramingElementDesignProperties.cs index ed3be5d8..2b3a38f0 100644 --- a/Robot_Adapter/CRUD/Read/Properties/FramingElementDesignProperties.cs +++ b/Robot_Adapter/CRUD/Read/Properties/FramingElementDesignProperties.cs @@ -75,6 +75,45 @@ private List ReadFramingElementDesignProperties( IRDimMembParamsE32 memberDesignParams_EC3 = memberDef.CodeParams; bhomDesignProps.EulerBucklingLengthCoefficientY = memberDesignParams_EC3.BuckLengthCoeffY; bhomDesignProps.EulerBucklingLengthCoefficientZ = memberDesignParams_EC3.BuckLengthCoeffZ; + + // Read lateral torsional buckling parameters + LateralTorsionalBucklingParameters ltbParams = new LateralTorsionalBucklingParameters(); + ltbParams.LateralBucklingEnabled = memberDesignParams_EC3.LateralBuckling; + + if (ltbParams.LateralBucklingEnabled) + { + ltbParams.LoadLevelUpperFlangeValue = memberDesignParams_EC3.LatCoeffUpperFlangeValue; + ltbParams.LoadLevelLowerFlangeValue = memberDesignParams_EC3.LatCoeffLowerFlangeValue; + ltbParams.LoadLevelUpperFlangeAuto = memberDesignParams_EC3.LatCoeffUpperFlangeValue == 0; + ltbParams.LoadLevelLowerFlangeAuto = memberDesignParams_EC3.LatCoeffLowerFlangeValue == 0; + ltbParams.LambdaLT0 = memberDesignParams_EC3.LamLT0; + ltbParams.Beta = memberDesignParams_EC3.Beta; + ltbParams.Kfl = memberDesignParams_EC3.Kfl; + + IRDimLatBuckMethodTypeE32 lateralBucklingMethodType = memberDesignParams_EC3.LatBuckMethodType; + // Convert enum to int - values will be preserved + ltbParams.LateralBucklingMethodType = (int)lateralBucklingMethodType; + } + + bhomDesignProps.LateralTorsionalBuckling = ltbParams; + + // Read service limit state parameters + ServiceLimitStateParameters slsParams = new ServiceLimitStateParameters(); + double deflectionLimit_relativeY = memberDesignParams_EC3.RelLimitDeflUy; + double deflectionLimit_relativeZ = memberDesignParams_EC3.RelLimitdeflUz; + + // Check if deflection limits are set (non-zero values indicate they are configured) + if (deflectionLimit_relativeY > 0 || deflectionLimit_relativeZ > 0) + { + slsParams.DeflectionLimitEnabled = true; + slsParams.RelativeDeflectionLimitY = deflectionLimit_relativeY; + slsParams.RelativeDeflectionLimitZ = deflectionLimit_relativeZ; + slsParams.UseRelativeLimitY = true; + slsParams.UseRelativeLimitZ = true; + } + + bhomDesignProps.ServiceLimitState = slsParams; + //RobotEurocodeSteelDesignFactors mEuroCodeDesignFactors = rMemberType.Data; bool angle_conn = memberDesignParams_EC3.AngleConn; double beta = memberDesignParams_EC3.Beta; @@ -94,7 +133,7 @@ private List ReadFramingElementDesignProperties( bool isHotRolledPipe = memberDesignParams_EC3.HotRolledPipes; double kfi = memberDesignParams_EC3.Kfl; double lambda_LT0 = memberDesignParams_EC3.LamLT0; - IRDimLatBuckMethodTypeE32 lateralBucklingMethodType = memberDesignParams_EC3.LatBuckMethodType; + IRDimLatBuckMethodTypeE32 lateralBucklingMethodType2 = memberDesignParams_EC3.LatBuckMethodType; IRDimLatBuckCoeffDiagramE32 lateralBucklingCoefficientDiagram_LowerFlange = memberDesignParams_EC3.LatCoeffLowerFlange; IRDimLatBuckCoeffDiagramE32 lateralBucklingCoefficientDiagram_UpperFlange = memberDesignParams_EC3.LatCoeffUpperFlange; double lateralBucklingCoefficient_LowerFlange = memberDesignParams_EC3.LatCoeffLowerFlangeValue; @@ -107,8 +146,7 @@ private List ReadFramingElementDesignProperties( double materialCoefficient_Gamma0 = memberDesignParams_EC3.MaterCoeffGamma0; double materialCoefficient_Gamma1 = memberDesignParams_EC3.MaterCoeffGamma1; double materialCoefficient_Gamma2 = memberDesignParams_EC3.MaterCoeffGamma2; - double deflectionLimit_relativeY = memberDesignParams_EC3.RelLimitDeflUy; - double deflectionLimit_relativeZ = memberDesignParams_EC3.RelLimitdeflUz; + // Deflection limits already read above for service limit state parameters bool isSimplifiedParameters = memberDesignParams_EC3.Simplified; double tensileAreaNetGrossRatio = memberDesignParams_EC3.TensAreaNetGros; IRDimThinWalledE32 thinWalledProperties = memberDesignParams_EC3.ThinWalled; @@ -124,6 +162,18 @@ private List ReadFramingElementDesignProperties( IRDimMembParamsBS59 memberDesignParams_BS5950 = memberDef.CodeParams; bhomDesignProps.EulerBucklingLengthCoefficientY = memberDesignParams_BS5950.BuckLengthCoeffY; bhomDesignProps.EulerBucklingLengthCoefficientZ = memberDesignParams_BS5950.BuckLengthCoeffZ; + + // Read lateral torsional buckling parameters + LateralTorsionalBucklingParameters ltbParams = new LateralTorsionalBucklingParameters(); + // Note: BS5950 interface may not have direct LateralBuckling property + // Check for alternative properties or set default values + ltbParams.LateralBucklingEnabled = false; // Default value + bhomDesignProps.LateralTorsionalBuckling = ltbParams; + + // Read service limit state parameters + ServiceLimitStateParameters slsParams = new ServiceLimitStateParameters(); + // Note: BS5950 deflection parameters would be added here if available in Robot API + bhomDesignProps.ServiceLimitState = slsParams; } @@ -132,6 +182,37 @@ private List ReadFramingElementDesignProperties( IRDimMembParamsBS59_2000 memberDesignParams_BS5950_2000 = memberDef.CodeParams; bhomDesignProps.EulerBucklingLengthCoefficientY = memberDesignParams_BS5950_2000.BuckLengthCoeffY; bhomDesignProps.EulerBucklingLengthCoefficientZ = memberDesignParams_BS5950_2000.BuckLengthCoeffZ; + + // Read lateral torsional buckling parameters + LateralTorsionalBucklingParameters ltbParams = new LateralTorsionalBucklingParameters(); + // Note: BS5950_2000 interface may not have direct LateralBuckling property + // Check for alternative properties or set default values + ltbParams.LateralBucklingEnabled = false; // Default value + bhomDesignProps.LateralTorsionalBuckling = ltbParams; + + // Read service limit state parameters + ServiceLimitStateParameters slsParams = new ServiceLimitStateParameters(); + // Note: BS5950_2000 deflection parameters would be added here if available in Robot API + bhomDesignProps.ServiceLimitState = slsParams; + } + + if (steelMembersCodeType == BHE.Query.GetStringFromEnum(DesignCode_Steel.ANSI_AISC_360_10)) + { + IRDimMembParamsANS memberDesignParams_AISC_360_10 = memberDef.CodeParams; + bhomDesignProps.EulerBucklingLengthCoefficientY = memberDesignParams_AISC_360_10.BuckLenghtCoeffY; + bhomDesignProps.EulerBucklingLengthCoefficientZ = memberDesignParams_AISC_360_10.BuckLenghtCoeffZ; + + // Read lateral torsional buckling parameters + LateralTorsionalBucklingParameters ltbParams = new LateralTorsionalBucklingParameters(); + // Note: ANSI_AISC_360_10 interface may not have direct LateralBuckling property + // Check for alternative properties or set default values + ltbParams.LateralBucklingEnabled = false; // Default value + bhomDesignProps.LateralTorsionalBuckling = ltbParams; + + // Read service limit state parameters + ServiceLimitStateParameters slsParams = new ServiceLimitStateParameters(); + // Note: ANSI_AISC_360_10 deflection parameters would be added here if available in Robot API + bhomDesignProps.ServiceLimitState = slsParams; } diff --git a/Robot_Adapter/CRUD/Update/Elements/Bars.cs b/Robot_Adapter/CRUD/Update/Elements/Bars.cs index 7ef9b5a8..6193e199 100644 --- a/Robot_Adapter/CRUD/Update/Elements/Bars.cs +++ b/Robot_Adapter/CRUD/Update/Elements/Bars.cs @@ -95,7 +95,7 @@ protected bool Update(IEnumerable bars) FramingElementDesignProperties framEleDesProps = designFragment as FramingElementDesignProperties; if (framEleDesProps != null) { - if (m_RobotApplication.Project.Structure.Labels.Exist(IRobotLabelType.I_LT_MEMBER_TYPE, framEleDesProps.Name) != -1) + if (m_RobotApplication.Project.Structure.Labels.Exist(IRobotLabelType.I_LT_MEMBER_TYPE, framEleDesProps.Name) == 0) Create(framEleDesProps); robotBar.SetLabel(IRobotLabelType.I_LT_MEMBER_TYPE, framEleDesProps.Name); } diff --git a/Robot_Adapter/CRUD/Update/Properties/FramingElementDesignProperties.cs b/Robot_Adapter/CRUD/Update/Properties/FramingElementDesignProperties.cs index 971b6f0e..7b11de81 100644 --- a/Robot_Adapter/CRUD/Update/Properties/FramingElementDesignProperties.cs +++ b/Robot_Adapter/CRUD/Update/Properties/FramingElementDesignProperties.cs @@ -38,36 +38,26 @@ protected bool Update(IEnumerable framingElement foreach (FramingElementDesignProperties framEleDesProps in framingElementDesignPropertiesList) { - - IRobotLabel memberType = m_RobotApplication.Project.Structure.Labels.Get(IRobotLabelType.I_LT_MEMBER_TYPE, framEleDesProps.Name); - - string steelMembersCodeType = m_RobotApplication.Project.Preferences.GetActiveCode(IRobotCodeType.I_CT_STEEL_STRUCTURES); + if (!CheckNotNull(framEleDesProps, oM.Base.Debugging.EventType.Warning)) + continue; - IRDimMembDef memberDef = memberType.Data; - - if (steelMembersCodeType == BHE.Query.GetStringFromEnum(DesignCode_Steel.BS_EN_1993_1_2005_NA_2008_A1_2014)) + // Check if the label exists before trying to update it + if (m_RobotApplication.Project.Structure.Labels.Exist(IRobotLabelType.I_LT_MEMBER_TYPE, framEleDesProps.Name) == 0) { - IRDimMembParamsE32 memberDesignParams_EC3 = memberDef.CodeParams; - memberDesignParams_EC3.BuckLengthCoeffY = framEleDesProps.EulerBucklingLengthCoefficientY; - memberDesignParams_EC3.BuckLengthCoeffZ = framEleDesProps.EulerBucklingLengthCoefficientZ; - memberDef.CodeParams = memberDesignParams_EC3; + Engine.Base.Compute.RecordWarning($"FramingElementDesignProperties '{framEleDesProps.Name}' does not exist in Robot and cannot be updated. Use Create instead."); + continue; } - if (steelMembersCodeType == BHE.Query.GetStringFromEnum(DesignCode_Steel.BS5950)) + IRobotLabel memberType = m_RobotApplication.Project.Structure.Labels.Get(IRobotLabelType.I_LT_MEMBER_TYPE, framEleDesProps.Name); + + if (memberType == null) { - IRDimMembParamsBS59 memberDesignParams_BS5950 = memberDef.CodeParams; - memberDesignParams_BS5950.BuckLengthCoeffY = framEleDesProps.EulerBucklingLengthCoefficientY; - memberDesignParams_BS5950.BuckLengthCoeffZ = framEleDesProps.EulerBucklingLengthCoefficientZ; - memberDef.CodeParams = memberDesignParams_BS5950; + Engine.Base.Compute.RecordWarning($"Failed to retrieve FramingElementDesignProperties '{framEleDesProps.Name}' from Robot."); + continue; } - if (steelMembersCodeType == BHE.Query.GetStringFromEnum(DesignCode_Steel.BS5950_2000)) - { - IRDimMembParamsBS59_2000 memberDesignParams_BS5950_2000 = memberDef.CodeParams; - memberDesignParams_BS5950_2000.BuckLengthCoeffY = framEleDesProps.EulerBucklingLengthCoefficientY; - memberDesignParams_BS5950_2000.BuckLengthCoeffZ = framEleDesProps.EulerBucklingLengthCoefficientZ; - memberDef.CodeParams = memberDesignParams_BS5950_2000; - } + // Use the ToRobot method with the configured design code + Convert.ToRobot(memberType, framEleDesProps, RobotConfig.DatabaseSettings.SteelDesignCode); m_RobotApplication.Project.Structure.Labels.Store(memberType); } diff --git a/Robot_Adapter/Convert/ToRobot/Properties/MemberType.cs b/Robot_Adapter/Convert/ToRobot/Properties/MemberType.cs index 0eb28482..a03f6f8d 100644 --- a/Robot_Adapter/Convert/ToRobot/Properties/MemberType.cs +++ b/Robot_Adapter/Convert/ToRobot/Properties/MemberType.cs @@ -31,65 +31,140 @@ public static partial class Convert /**** Public Methods ****/ /***************************************************/ - public static void ToRobot(IRobotLabel robotMemberType, FramingElementDesignProperties framingElementDesignProperties) + public static void ToRobot(IRobotLabel robotMemberType, FramingElementDesignProperties framingElementDesignProperties, DesignCode_Steel designCode) { - - //RobotEurocodeSteelDesignFactors mEuroCodeDesignFactors = robotMemberType.Data; - //string name = robotMemberType.Name; - //object rMemberTypeData = robotMemberType.Data; - - //IRDimMembDef memberDef = robotMemberType.Data; - - //double length = memberDef.Length; - - //IRDimMembParamsE32 memberDesignParams_EC3 = memberDef.CodeParams; - //bool angle_conn = memberDesignParams_EC3.AngleConn; - //double beta = memberDesignParams_EC3.Beta; - //double boltsDiameter = memberDesignParams_EC3.BoltsDiam; - //int numberOfBolts = memberDesignParams_EC3.BoltsNo; - //bool isBracedInY = memberDesignParams_EC3.BracedY; - //bool isBracedInZ = memberDesignParams_EC3.BracedZ; - //double bucklingLengthCoefficientY = memberDesignParams_EC3.BuckLengthCoeffY; - //double bucklingLengthCoefficientZ = memberDesignParams_EC3.BuckLengthCoeffZ; - //IRDimBucklingCurveE32 bucklingCurveY = memberDesignParams_EC3.BucklingCurveY; - //IRDimBucklingCurveE32 bucklingCurveZ = memberDesignParams_EC3.BucklingCurveZ; - //IRDimBuckDiagramE32 bucklingDiagramY = memberDesignParams_EC3.BucklingDiagramY; - //IRDimBuckDiagramE32 bucklingDiagramZ = memberDesignParams_EC3.BucklingDiagramZ; - //IRDimComplexSectE32 complexSection = memberDesignParams_EC3.ComplexSect; - //double boltEdgeDistance_E2 = memberDesignParams_EC3.DistE2; - //double boltSpacing_P1 = memberDesignParams_EC3.DistP1; - //double shearParameter_ETA = memberDesignParams_EC3.Eta; - //IRDimFireResistE32 fireResistance = memberDesignParams_EC3.FireResist; - //bool isHotRolledPipe = memberDesignParams_EC3.HotRolledPipes; - //double kfi = memberDesignParams_EC3.Kfl; - //double lambda_LT0 = memberDesignParams_EC3.LamLT0; - //IRDimLatBuckMethodTypeE32 lateralBucklingMethodType = memberDesignParams_EC3.LatBuckMethodType; - //IRDimLatBuckCoeffDiagramE32 lateralBucklingCoefficientDiagram_LowerFlange = memberDesignParams_EC3.LatCoeffLowerFlange; - //IRDimLatBuckCoeffDiagramE32 lateralBucklingCoefficientDiagram_UpperFlange = memberDesignParams_EC3.LatCoeffUpperFlange; - //double lateralBucklingCoefficient_LowerFlange = memberDesignParams_EC3.LatCoeffLowerFlangeValue; - //double lateralBucklingCoefficient_UpperFlange = memberDesignParams_EC3.LatCoeffUpperFlangeValue; - //bool considerLeteralBuckling = memberDesignParams_EC3.LateralBuckling; - //IRDimLoadLevelE32 loadLevel = memberDesignParams_EC3.LoadLevel; - //double loadLevelValue = memberDesignParams_EC3.LoadLevelValue; - //IRDimLoadTypeE32 loadTypeY = memberDesignParams_EC3.LoadTypeY; - //IRDimLoadTypeE32 loadTypeZ = memberDesignParams_EC3.LoadTypeZ; - //double materialCoefficient_Gamma0 = memberDesignParams_EC3.MaterCoeffGamma0; - //double materialCoefficient_Gamma1 = memberDesignParams_EC3.MaterCoeffGamma1; - //double materialCoefficient_Gamma2 = memberDesignParams_EC3.MaterCoeffGamma2; - //double deflectionLimit_relativeY = memberDesignParams_EC3.RelLimitDeflUy; - //double deflectionLimit_relativeZ = memberDesignParams_EC3.RelLimitdeflUz; - //bool isSimplifiedParameters = memberDesignParams_EC3.Simplified; - //double tensileAreaNetGrossRatio = memberDesignParams_EC3.TensAreaNetGros; - //IRDimThinWalledE32 thinWalledProperties = memberDesignParams_EC3.ThinWalled; - //bool considerTorsionalBuckling = memberDesignParams_EC3.TorsBuckOn; - //bool tubeControl = memberDesignParams_EC3.TubeControl; - //IRDimYieldStrengthTypeE32 yieldStrengthType = memberDesignParams_EC3.YieldStrengthType; - //double yieldStrengthValue = memberDesignParams_EC3.YieldStrengthValue; - - //FramingElementDesignProperties bhomDesignProps = BHE.Create.FramingElementDesignProperties(rMemberType.Name); - - //bhomDesignPropsList.Add(bhomDesignProps); + if (robotMemberType == null || framingElementDesignProperties == null) + return; + IRDimMembDef memberDef = robotMemberType.Data; + + if (memberDef == null) + return; + + // Set member lengths if specified + if (framingElementDesignProperties.MemberLengthYIsRelative) + memberDef.SetLengthYZUV(IRDimMembDefLengthDataType.I_DMDLDT_LENGTH_Y, -framingElementDesignProperties.MemberLengthY); + else + memberDef.SetLengthYZUV(IRDimMembDefLengthDataType.I_DMDLDT_LENGTH_Y, framingElementDesignProperties.MemberLengthY); + + if (framingElementDesignProperties.MemberLengthZIsRelative) + memberDef.SetLengthYZUV(IRDimMembDefLengthDataType.I_DMDLDT_LENGTH_Z, -framingElementDesignProperties.MemberLengthZ); + else + memberDef.SetLengthYZUV(IRDimMembDefLengthDataType.I_DMDLDT_LENGTH_Z, framingElementDesignProperties.MemberLengthZ); + + // Set buckling length coefficients based on the specified design code + if (designCode == DesignCode_Steel.BS_EN_1993_1_2005_NA_2008_A1_2014) + { + IRDimMembParamsE32 memberDesignParams_EC3 = memberDef.CodeParams; + memberDesignParams_EC3.BuckLengthCoeffY = framingElementDesignProperties.EulerBucklingLengthCoefficientY; + memberDesignParams_EC3.BuckLengthCoeffZ = framingElementDesignProperties.EulerBucklingLengthCoefficientZ; + + // Set lateral torsional buckling parameters if provided + if (framingElementDesignProperties.LateralTorsionalBuckling != null) + { + var ltb = framingElementDesignProperties.LateralTorsionalBuckling; + memberDesignParams_EC3.LateralBuckling = ltb.LateralBucklingEnabled; + + if (ltb.LateralBucklingEnabled) + { + memberDesignParams_EC3.LatCoeffUpperFlangeValue = ltb.LoadLevelUpperFlangeAuto ? 0 : ltb.LoadLevelUpperFlangeValue; + memberDesignParams_EC3.LatCoeffLowerFlangeValue = ltb.LoadLevelLowerFlangeAuto ? 0 : ltb.LoadLevelLowerFlangeValue; + memberDesignParams_EC3.LamLT0 = ltb.LambdaLT0; + memberDesignParams_EC3.Beta = ltb.Beta; + memberDesignParams_EC3.Kfl = ltb.Kfl; + } + } + + // Set service limit state parameters if provided + if (framingElementDesignProperties.ServiceLimitState != null) + { + var sls = framingElementDesignProperties.ServiceLimitState; + if (sls.DeflectionLimitEnabled) + { + if (sls.UseRelativeLimitY) + memberDesignParams_EC3.RelLimitDeflUy = sls.RelativeDeflectionLimitY; + if (sls.UseRelativeLimitZ) + memberDesignParams_EC3.RelLimitdeflUz = sls.RelativeDeflectionLimitZ; + } + } + + memberDef.CodeParams = memberDesignParams_EC3; + } + else if (designCode == DesignCode_Steel.BS5950) + { + IRDimMembParamsBS59 memberDesignParams_BS5950 = memberDef.CodeParams; + memberDesignParams_BS5950.BuckLengthCoeffY = framingElementDesignProperties.EulerBucklingLengthCoefficientY; + memberDesignParams_BS5950.BuckLengthCoeffZ = framingElementDesignProperties.EulerBucklingLengthCoefficientZ; + + // Set lateral torsional buckling parameters if provided + if (framingElementDesignProperties.LateralTorsionalBuckling != null) + { + var ltb = framingElementDesignProperties.LateralTorsionalBuckling; + // Note: BS5950 interface may not have direct LateralBuckling property + // Check Robot API documentation for available properties + // memberDesignParams_BS5950.LateralBuckling = ltb.LateralBucklingEnabled; + } + + // Set service limit state parameters if provided + if (framingElementDesignProperties.ServiceLimitState != null) + { + var sls = framingElementDesignProperties.ServiceLimitState; + // Note: BS5950 may have different deflection limit properties + // Implementation would depend on available Robot API properties + } + + memberDef.CodeParams = memberDesignParams_BS5950; + } + else if (designCode == DesignCode_Steel.BS5950_2000) + { + IRDimMembParamsBS59_2000 memberDesignParams_BS5950_2000 = memberDef.CodeParams; + memberDesignParams_BS5950_2000.BuckLengthCoeffY = framingElementDesignProperties.EulerBucklingLengthCoefficientY; + memberDesignParams_BS5950_2000.BuckLengthCoeffZ = framingElementDesignProperties.EulerBucklingLengthCoefficientZ; + + // Set lateral torsional buckling parameters if provided + if (framingElementDesignProperties.LateralTorsionalBuckling != null) + { + var ltb = framingElementDesignProperties.LateralTorsionalBuckling; + // Note: BS5950_2000 interface may not have direct LateralBuckling property + // Check Robot API documentation for available properties + // memberDesignParams_BS5950_2000.LateralBuckling = ltb.LateralBucklingEnabled; + } + + // Set service limit state parameters if provided + if (framingElementDesignProperties.ServiceLimitState != null) + { + var sls = framingElementDesignProperties.ServiceLimitState; + // Note: BS5950_2000 may have different deflection limit properties + // Implementation would depend on available Robot API properties + } + + memberDef.CodeParams = memberDesignParams_BS5950_2000; + } + else if (designCode == DesignCode_Steel.ANSI_AISC_360_10) + { + IRDimMembParamsANS memberDesignParams_AISC_360_10 = memberDef.CodeParams; + memberDesignParams_AISC_360_10.BuckLenghtCoeffY = framingElementDesignProperties.EulerBucklingLengthCoefficientY; + memberDesignParams_AISC_360_10.BuckLenghtCoeffZ = framingElementDesignProperties.EulerBucklingLengthCoefficientZ; + + // Set lateral torsional buckling parameters if provided + if (framingElementDesignProperties.LateralTorsionalBuckling != null) + { + var ltb = framingElementDesignProperties.LateralTorsionalBuckling; + // Note: ANSI_AISC_360_10 interface may not have direct LateralBuckling property + // Check Robot API documentation for available properties + // memberDesignParams_AISC_360_10.LateralBuckling = ltb.LateralBucklingEnabled; + } + + // Set service limit state parameters if provided + if (framingElementDesignProperties.ServiceLimitState != null) + { + var sls = framingElementDesignProperties.ServiceLimitState; + // Note: ANSI_AISC_360_10 may have different deflection limit properties + // Implementation would depend on available Robot API properties + } + + memberDef.CodeParams = memberDesignParams_AISC_360_10; + } } /***************************************************/ diff --git a/Robot_Engine/Create/FramingElementDesignProperties.cs b/Robot_Engine/Create/FramingElementDesignProperties.cs index b1f697dd..0721acf8 100644 --- a/Robot_Engine/Create/FramingElementDesignProperties.cs +++ b/Robot_Engine/Create/FramingElementDesignProperties.cs @@ -53,6 +53,24 @@ public static FramingElementDesignProperties FramingElementDesignProperties(stri } /***************************************************/ + + public static FramingElementDesignProperties FramingElementDesignProperties(string name, + double eulerBucklingLengthCoeffY = 1, + double eulerBucklingLengthCoeffZ = 1, + LateralTorsionalBucklingParameters lateralTorsionalBuckling = null, + ServiceLimitStateParameters serviceLimitState = null) + { + FramingElementDesignProperties framEleDesignProps = new FramingElementDesignProperties(); + framEleDesignProps.Name = name; + framEleDesignProps.EulerBucklingLengthCoefficientY = eulerBucklingLengthCoeffY; + framEleDesignProps.EulerBucklingLengthCoefficientZ = eulerBucklingLengthCoeffZ; + framEleDesignProps.LateralTorsionalBuckling = lateralTorsionalBuckling; + framEleDesignProps.ServiceLimitState = serviceLimitState; + + return framEleDesignProps; + } + + /***************************************************/ } } diff --git a/Robot_Engine/Create/LateralTorsionalBucklingParameters.cs b/Robot_Engine/Create/LateralTorsionalBucklingParameters.cs new file mode 100644 index 00000000..f9540a72 --- /dev/null +++ b/Robot_Engine/Create/LateralTorsionalBucklingParameters.cs @@ -0,0 +1,67 @@ +/* + * This file is part of the Buildings and Habitats object Model (BHoM) + * Copyright (c) 2015 - 2025, the respective contributors. All rights reserved. + * + * Each contributor holds copyright over their respective contributions. + * The project versioning (Git) records all such contribution source information. + * + * + * The BHoM is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3.0 of the License, or + * (at your option) any later version. + * + * The BHoM is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this code. If not, see . + */ + +using BH.oM.Adapters.Robot; + +namespace BH.Engine.Adapters.Robot +{ + public static partial class Create + { + /***************************************************/ + /**** Public Constructors ****/ + /***************************************************/ + + public static LateralTorsionalBucklingParameters LateralTorsionalBucklingParameters(bool lateralBucklingEnabled = false, + double lateralBucklingLengthCoefficient = 1.0, + bool loadLevelUpperFlangeAuto = true, + double loadLevelUpperFlangeValue = 1.0, + bool loadLevelLowerFlangeAuto = true, + double loadLevelLowerFlangeValue = 1.0, + bool criticalMomentAuto = true, + double criticalMomentValue = 1.0, + string lateralBucklingCurve = "auto", + int lateralBucklingMethodType = 0, + double lambdaLT0 = 0.4, + double beta = 0.75, + double kfl = 1.0) + { + LateralTorsionalBucklingParameters ltbParams = new LateralTorsionalBucklingParameters(); + ltbParams.LateralBucklingEnabled = lateralBucklingEnabled; + ltbParams.LateralBucklingLengthCoefficient = lateralBucklingLengthCoefficient; + ltbParams.LoadLevelUpperFlangeAuto = loadLevelUpperFlangeAuto; + ltbParams.LoadLevelUpperFlangeValue = loadLevelUpperFlangeValue; + ltbParams.LoadLevelLowerFlangeAuto = loadLevelLowerFlangeAuto; + ltbParams.LoadLevelLowerFlangeValue = loadLevelLowerFlangeValue; + ltbParams.CriticalMomentAuto = criticalMomentAuto; + ltbParams.CriticalMomentValue = criticalMomentValue; + ltbParams.LateralBucklingCurve = lateralBucklingCurve; + ltbParams.LateralBucklingMethodType = lateralBucklingMethodType; + ltbParams.LambdaLT0 = lambdaLT0; + ltbParams.Beta = beta; + ltbParams.Kfl = kfl; + + return ltbParams; + } + + /***************************************************/ + } +} \ No newline at end of file diff --git a/Robot_Engine/Create/ServiceLimitStateParameters.cs b/Robot_Engine/Create/ServiceLimitStateParameters.cs new file mode 100644 index 00000000..5fdcc6dc --- /dev/null +++ b/Robot_Engine/Create/ServiceLimitStateParameters.cs @@ -0,0 +1,55 @@ +/* + * This file is part of the Buildings and Habitats object Model (BHoM) + * Copyright (c) 2015 - 2025, the respective contributors. All rights reserved. + * + * Each contributor holds copyright over their respective contributions. + * The project versioning (Git) records all such contribution source information. + * + * + * The BHoM is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3.0 of the License, or + * (at your option) any later version. + * + * The BHoM is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this code. If not, see . + */ + +using BH.oM.Adapters.Robot; + +namespace BH.Engine.Adapters.Robot +{ + public static partial class Create + { + /***************************************************/ + /**** Public Constructors ****/ + /***************************************************/ + + public static ServiceLimitStateParameters ServiceLimitStateParameters(bool deflectionLimitEnabled = false, + double relativeDeflectionLimitY = 250.0, + double relativeDeflectionLimitZ = 250.0, + double absoluteDeflectionLimitY = 0.0, + double absoluteDeflectionLimitZ = 0.0, + bool useRelativeLimitY = true, + bool useRelativeLimitZ = true) + { + ServiceLimitStateParameters slsParams = new ServiceLimitStateParameters(); + slsParams.DeflectionLimitEnabled = deflectionLimitEnabled; + slsParams.RelativeDeflectionLimitY = relativeDeflectionLimitY; + slsParams.RelativeDeflectionLimitZ = relativeDeflectionLimitZ; + slsParams.AbsoluteDeflectionLimitY = absoluteDeflectionLimitY; + slsParams.AbsoluteDeflectionLimitZ = absoluteDeflectionLimitZ; + slsParams.UseRelativeLimitY = useRelativeLimitY; + slsParams.UseRelativeLimitZ = useRelativeLimitZ; + + return slsParams; + } + + /***************************************************/ + } +} \ No newline at end of file diff --git a/Robot_oM/Robot_oM.csproj b/Robot_oM/Robot_oM.csproj index ca2923ef..01a5ca82 100644 --- a/Robot_oM/Robot_oM.csproj +++ b/Robot_oM/Robot_oM.csproj @@ -78,6 +78,8 @@ + + @@ -98,4 +100,4 @@ --> - + \ No newline at end of file diff --git a/Robot_oM/Structural/Properties/FramingElementDesignProperties.cs b/Robot_oM/Structural/Properties/FramingElementDesignProperties.cs index d99d41d4..b09ba06a 100644 --- a/Robot_oM/Structural/Properties/FramingElementDesignProperties.cs +++ b/Robot_oM/Structural/Properties/FramingElementDesignProperties.cs @@ -36,6 +36,8 @@ public class FramingElementDesignProperties : BHoMObject, IFragment public virtual double MemberLengthZ { get; set; } = 1; public virtual bool MemberLengthYIsRelative { get; set; } = true; public virtual bool MemberLengthZIsRelative { get; set; } = true; + public virtual LateralTorsionalBucklingParameters LateralTorsionalBuckling { get; set; } = null; + public virtual ServiceLimitStateParameters ServiceLimitState { get; set; } = null; /***************************************************/ diff --git a/Robot_oM/Structural/Properties/LateralTorsionalBucklingParameters.cs b/Robot_oM/Structural/Properties/LateralTorsionalBucklingParameters.cs new file mode 100644 index 00000000..20c2c842 --- /dev/null +++ b/Robot_oM/Structural/Properties/LateralTorsionalBucklingParameters.cs @@ -0,0 +1,100 @@ +/* + * This file is part of the Buildings and Habitats object Model (BHoM) + * Copyright (c) 2015 - 2025, the respective contributors. All rights reserved. + * + * Each contributor holds copyright over their respective contributions. + * The project versioning (Git) records all such contribution source information. + * + * + * The BHoM is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3.0 of the License, or + * (at your option) any later version. + * + * The BHoM is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this code. If not, see . + */ + +using BH.oM.Base; + +namespace BH.oM.Adapters.Robot +{ + public class LateralTorsionalBucklingParameters : BHoMObject + { + /***************************************************/ + /**** Public Properties ****/ + /***************************************************/ + + /// + /// Enables or disables lateral torsional buckling consideration + /// + public virtual bool LateralBucklingEnabled { get; set; } = false; + + /// + /// Lateral buckling length coefficient + /// + public virtual double LateralBucklingLengthCoefficient { get; set; } = 1.0; + + /// + /// Load level for upper flange (Auto = true, User = false) + /// + public virtual bool LoadLevelUpperFlangeAuto { get; set; } = true; + + /// + /// Load level value for upper flange (when LoadLevelUpperFlangeAuto = false) + /// + public virtual double LoadLevelUpperFlangeValue { get; set; } = 1.0; + + /// + /// Load level for lower flange (Auto = true, User = false) + /// + public virtual bool LoadLevelLowerFlangeAuto { get; set; } = true; + + /// + /// Load level value for lower flange (when LoadLevelLowerFlangeAuto = false) + /// + public virtual double LoadLevelLowerFlangeValue { get; set; } = 1.0; + + /// + /// Critical moment calculation method (Auto = true, User = false) + /// + public virtual bool CriticalMomentAuto { get; set; } = true; + + /// + /// Critical moment value (when CriticalMomentAuto = false) + /// + public virtual double CriticalMomentValue { get; set; } = 1.0; + + /// + /// Lateral buckling curve (auto calculated based on section) + /// + public virtual string LateralBucklingCurve { get; set; } = "auto"; + + /// + /// Lateral buckling method type (General = 0, Detailed = 1, Simplified = 2) + /// + public virtual int LateralBucklingMethodType { get; set; } = 0; + + /// + /// Lambda LT,0 parameter for detailed method + /// + public virtual double LambdaLT0 { get; set; } = 0.4; + + /// + /// Beta parameter for detailed method + /// + public virtual double Beta { get; set; } = 0.75; + + /// + /// kfl parameter for detailed method + /// + public virtual double Kfl { get; set; } = 1.0; + + /***************************************************/ + } +} \ No newline at end of file diff --git a/Robot_oM/Structural/Properties/ServiceLimitStateParameters.cs b/Robot_oM/Structural/Properties/ServiceLimitStateParameters.cs new file mode 100644 index 00000000..838cab93 --- /dev/null +++ b/Robot_oM/Structural/Properties/ServiceLimitStateParameters.cs @@ -0,0 +1,70 @@ +/* + * This file is part of the Buildings and Habitats object Model (BHoM) + * Copyright (c) 2015 - 2025, the respective contributors. All rights reserved. + * + * Each contributor holds copyright over their respective contributions. + * The project versioning (Git) records all such contribution source information. + * + * + * The BHoM is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3.0 of the License, or + * (at your option) any later version. + * + * The BHoM is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this code. If not, see . + */ + +using BH.oM.Base; + +namespace BH.oM.Adapters.Robot +{ + public class ServiceLimitStateParameters : BHoMObject + { + /***************************************************/ + /**** Public Properties ****/ + /***************************************************/ + + /// + /// Enables or disables deflection and displacement limit checking + /// + public virtual bool DeflectionLimitEnabled { get; set; } = false; + + /// + /// Relative deflection limit in Y direction (as a fraction of span length) + /// + public virtual double RelativeDeflectionLimitY { get; set; } = 250.0; + + /// + /// Relative deflection limit in Z direction (as a fraction of span length) + /// + public virtual double RelativeDeflectionLimitZ { get; set; } = 250.0; + + /// + /// Absolute deflection limit in Y direction (in model units) + /// + public virtual double AbsoluteDeflectionLimitY { get; set; } = 0.0; + + /// + /// Absolute deflection limit in Z direction (in model units) + /// + public virtual double AbsoluteDeflectionLimitZ { get; set; } = 0.0; + + /// + /// Whether to use relative deflection limits (true) or absolute limits (false) for Y direction + /// + public virtual bool UseRelativeLimitY { get; set; } = true; + + /// + /// Whether to use relative deflection limits (true) or absolute limits (false) for Z direction + /// + public virtual bool UseRelativeLimitZ { get; set; } = true; + + /***************************************************/ + } +} \ No newline at end of file