/***************************************************/ /**** Private methods ****/ /***************************************************/ private List <ContourLoadSet> ReadContourLoadSets(List <string> ids = null) { //Implement code for reading Contour Load Sets List <ContourLoadSet> bhomContourLoadSets = new List <ContourLoadSet>(); Dictionary <int, UniformLoadSet> bhomUniformLoadSets = ReadUniformLoadSets().ToDictionary(x => (int)GetAdapterId(x)); //Get stories IStories IStories = m_Model.GetStories(); int numStories = IStories.GetCount(); // Get all elements on each story for (int i = 0; i < numStories; i++) { IFloorType floorType = IStories.GetAt(i).GetFloorType(); //Get contour load sets per story ISurfaceLoadSets srfLoadSets = floorType.GetSurfaceLoadSets2(); int numSrfLoads = srfLoadSets.GetCount(); for (int j = 0; j < numSrfLoads; j++) { ISurfaceLoadSet srfLoadSet = srfLoadSets.GetAt(j); ContourLoadSet srfLoad = srfLoadSet.ToBHoMObject(IStories.GetAt(i)); int propUID = srfLoadSet.lPropertySetUID; srfLoad.UniformLoadSet = bhomUniformLoadSets[propUID]; bhomContourLoadSets.Add(srfLoad); } } return(bhomContourLoadSets); }
/***************************************************/ /**** Private methods ****/ /***************************************************/ private bool CreateCollection(IEnumerable <ContourLoadSet> loads) { foreach (ContourLoadSet load in loads) { try { //Ensure points describe a closed polyline List <Point> loadPoints = load.Contour.ControlPoints(); if (loadPoints.First() != loadPoints.Last()) { loadPoints.Add(loadPoints.Last().DeepClone()); } //Find the layout to apply to IStories ramStories = m_Model.GetStories(); IStory loadStory = loadPoints.First().GetStory(ramStories); double storyElev = loadStory.dElevation; IFloorType floorType = loadStory.GetFloorType(); ISurfaceLoadSets floorLoads = floorType.GetSurfaceLoadSets2(); int nextId = floorLoads.GetCount(); ISurfaceLoadSet ramLoad = floorLoads.Add(nextId, loadPoints.Count()); IPoints verticePoints = ramLoad.GetPoints(); List <SCoordinate> checkList = new List <SCoordinate>(); SCoordinate verticeCoord; for (int i = 0; i < loadPoints.Count(); i++) { verticeCoord = loadPoints[i].ToRAM(); verticePoints.Delete(i); verticePoints.InsertAt2(i, verticeCoord.dXLoc, verticeCoord.dYLoc, 0); checkList.Add(verticeCoord); } ramLoad.SetPoints(verticePoints); ramLoad.lPropertySetUID = (int)GetAdapterId(load.UniformLoadSet); } catch { CreateElementError("UniformLoadSet", load.Name); } } //Save file m_IDBIO.SaveDatabase(); return(true); }
/***************************************************/ /**** Private methods ****/ /***************************************************/ private List <Panel> ReadPanels(List <string> ids = null) { //Get dictionary of surface properties with ids Dictionary <string, ISurfaceProperty> bhomProperties = ReadISurfaceProperties().ToDictionary(x => GetAdapterId(x).ToString()); //Implement code for reading panels List <Panel> bhomPanels = new List <Panel>(); //Get stories IStories IStories = m_Model.GetStories(); int numStories = IStories.GetCount(); // Get all elements on each story for (int i = 0; i < numStories; i++) { //Get Walls IWalls IWalls = IStories.GetAt(i).GetWalls(); int numWalls = IWalls.GetCount(); // Convert Walls for (int j = 0; j < numWalls; j++) { IWall IWall = IWalls.GetAt(j); Panel Panel = BH.Adapter.RAM.Convert.ToBHoMObject(IWall); bhomPanels.Add(Panel); } //Get Floors IStory IStory = IStories.GetAt(i); IFloorType IFloorType = IStory.GetFloorType(); IDecks IDecks = IFloorType.GetDecks(); int IStoryUID = IStory.lUID; int numDecks = IDecks.GetCount(); if (numDecks > 0) { // Convert Floors for (int j = 0; j < numDecks; j++) { IDeck IDeck = IDecks.GetAt(j); Panel panel = BH.Adapter.RAM.Convert.ToBHoMObject(IDeck, m_Model, IStoryUID); if (panel != null) { ISurfaceProperty bhProp = new ConstantThickness(); bhomProperties.TryGetValue(IDeck.lPropID.ToString(), out bhProp); if (bhProp != null) { panel.Property = bhProp; } else { Engine.Base.Compute.RecordWarning($"Could not get property for floor with RAM lUID = {IDeck.lUID}"); } bhomPanels.Add(panel); } } } else { BH.Engine.Base.Compute.RecordWarning("This story has no slab edges defined. IStoryUID: " + IStoryUID); break; } } return(bhomPanels); }
/***************************************************/ /**** Private methods ****/ /***************************************************/ private List <Bar> ReadBars(List <string> ids = null) { //Implement code for reading bars List <Bar> bhomBars = new List <Bar>(); // Get stories IStories IStories = m_Model.GetStories(); int numStories = IStories.GetCount(); // Get all elements on each story for (int i = 0; i < numStories; i++) { //Get Columns IColumns IColumns = IStories.GetAt(i).GetColumns(); int numColumns = IColumns.GetCount(); //Get Beams IFloorType IFloorType = IStories.GetAt(i).GetFloorType(); ILayoutBeams ILayoutBeams = IFloorType.GetLayoutBeams(); IBeams IBeams = IStories.GetAt(i).GetBeams(); int numLayoutBeams = ILayoutBeams.GetCount(); int numBeams = IBeams.GetCount(); //Get Vertical Braces IVerticalBraces IVBraces = IStories.GetAt(i).GetVerticalBraces(); int numVBraces = IVBraces.GetCount(); //Get Horizontal Braces ILayoutHorizBraces ILayoutHorizBraces = IStories.GetAt(i).GetFloorType().GetLayoutHorizBraces(); IHorizBraces IHorizBraces = IStories.GetAt(i).GetHorizBraces(); int numHBraces = ILayoutHorizBraces.GetCount(); //Get Elevation double dElevation = IStories.GetAt(i).dElevation; // Convert Columns for (int j = 0; j < numColumns; j++) { IColumn IColumn = IColumns.GetAt(j); Bar bhomBar = BH.Adapter.RAM.Convert.ToBHoMObject(IColumn); RAMFrameData ramFrameData = bhomBar.FindFragment <RAMFrameData>(typeof(RAMFrameData)); if (ramFrameData != null) { ramFrameData.FloorType = IFloorType.strLabel; bhomBar.Fragments.AddOrReplace(ramFrameData); } bhomBars.Add(bhomBar); } // Convert Beams for (int j = 0; j < numBeams; j++) { IBeam IBeam = IBeams.GetAt(j); ILayoutBeam ILayoutBeam = ILayoutBeams.GetAt(j); Bar bhomBar = BH.Adapter.RAM.Convert.ToBHoMObject(IBeam, ILayoutBeam, dElevation); RAMFrameData ramFrameData = bhomBar.FindFragment <RAMFrameData>(typeof(RAMFrameData)); if (ramFrameData != null) { ramFrameData.FloorType = IFloorType.strLabel; bhomBar.Fragments.AddOrReplace(ramFrameData); } bhomBars.Add(bhomBar); } // Convert Vertical Braces for (int j = 0; j < numVBraces; j++) { IVerticalBrace IVerticalBrace = IVBraces.GetAt(j); Bar bhomBar = BH.Adapter.RAM.Convert.ToBHoMObject(IVerticalBrace); RAMFrameData ramFrameData = bhomBar.FindFragment <RAMFrameData>(typeof(RAMFrameData)); if (ramFrameData != null) { ramFrameData.FloorType = IFloorType.strLabel; bhomBar.Fragments.AddOrReplace(ramFrameData); } bhomBars.Add(bhomBar); } // Convert Horizontal Braces for (int j = 0; j < numHBraces; j++) { IHorizBrace IHorizBrace = IHorizBraces.GetAt(j); ILayoutHorizBrace ILayoutHorizBrace = ILayoutHorizBraces.GetAt(j); Bar bhomBar = BH.Adapter.RAM.Convert.ToBHoMObject(IHorizBrace, ILayoutHorizBrace, dElevation); RAMFrameData ramFrameData = bhomBar.FindFragment <RAMFrameData>(typeof(RAMFrameData)); if (ramFrameData != null) { ramFrameData.FloorType = IFloorType.strLabel; bhomBar.Fragments.AddOrReplace(ramFrameData); } bhomBars.Add(bhomBar); } } return(bhomBars); }
/***************************************************/ /**** Private methods ****/ /***************************************************/ private bool CreateCollection(IEnumerable <Level> bhomLevels) { if (bhomLevels.Count() != 0) { //sort levels by elevation IOrderedEnumerable <Level> orderedBhomLevels = bhomLevels.OrderBy(o => o.Elevation); List <Level> sortedBhomLevels = new List <Level>(); //Check levels for negatives if (orderedBhomLevels.First().Elevation < 0) { throw new Exception("Base level can not be negative for RAM. Please move model origin point to set all geometry and levels at 0 or greater."); } //Check levels for base level = 0, remove if occurs if (orderedBhomLevels.First().Elevation == 0) { sortedBhomLevels = orderedBhomLevels.Where(level => level.Elevation != 0).ToList(); } else { sortedBhomLevels = orderedBhomLevels.Where(level => level.Elevation != 0).ToList(); } // Register Floor types IFloorTypes ramFloorTypes; IFloorType ramFloorType = null; IStories ramStories; //Create floor type at each level for (int i = 0; i < sortedBhomLevels.Count(); i++) { Level level = sortedBhomLevels.ElementAt(i); double levelHtDbl = level.Elevation.ToInch(); double levelHt = Math.Round(levelHtDbl, 3); // Get elevations and skip if level elevation already in RAM ramStories = m_Model.GetStories(); List <double> ramElevs = new List <double>(); List <string> ramStoryNames = new List <string>(); for (int j = 0; j < ramStories.GetCount(); j++) { ramElevs.Add(ramStories.GetAt(j).dElevation); ramStoryNames.Add(ramStories.GetAt(j).strLabel); } if (ramElevs.Contains(levelHt) != true && ramStoryNames.Contains(level.Name) != true) { double height; // Ground floor ht = 0 for RAM if (i == 0) { height = levelHt; } else { Level lastLevel = sortedBhomLevels.ElementAt(i - 1); height = levelHt - lastLevel.Elevation.ToInch(); } int newIndex; if (ramElevs.FindIndex(x => x > levelHt) == -1) { newIndex = ramElevs.Count(); } else { newIndex = ramElevs.FindIndex(x => x > levelHt); } List <string> ramFloorTypeNames = new List <string>(); ramFloorTypes = m_Model.GetFloorTypes(); Boolean floorTypeExists = false; for (int j = 0; j < ramFloorTypes.GetCount(); j++) { IFloorType testFloorType = ramFloorTypes.GetAt(j); if (testFloorType.strLabel == level.Name) { ramFloorType = testFloorType; floorTypeExists = true; } } if (floorTypeExists == false) { ramFloorType = ramFloorTypes.Add(level.Name); } // Modify story above if not top floor if (newIndex < ramStories.GetCount()) { IStory ramStoryAbove = ramStories.GetAt(newIndex); ramStoryAbove.dFlrHeight = ramStoryAbove.dElevation - levelHt; } if (newIndex > 0 && ramStories.GetCount() > 0) { IStory ramStoryBelow = ramStories.GetAt(newIndex - 1); height = levelHt - ramStoryBelow.dElevation; } // Insert story at index ramStories.InsertAt(newIndex, ramFloorType.lUID, level.Name, height); } } //Save file m_IDBIO.SaveDatabase(); } return(true); }
/***************************************************/ /**** Private methods ****/ /***************************************************/ private bool CreateCollection(IEnumerable <Bar> bhomBars) { //Code for creating a collection of bars in the software List <Bar> bars = bhomBars.ToList(); //Get the stories in the model IStories ramStories = m_Model.GetStories(); //Cycle through bars, split to beam and col lists, then add to corresponding story. List <Bar> barBeams = new List <Bar>(); List <Bar> barCols = new List <Bar>(); foreach (Bar testBar in bars) { bool isBeam = Math.Abs(testBar.Tangent(true).DotProduct(Vector.ZAxis)) < 0.5; if (isBeam) { barBeams.Add(testBar); } else { barCols.Add(testBar); } } //Create beams per story, flat foreach (Bar bar in barBeams) { string name = bar.Name; ILayoutBeam ramBeam; try { RAMId RAMId = new RAMId(); IStory barStory = bar.GetStory(StructuralUsage1D.Beam, ramStories); IFloorType ramFloorType = barStory.GetFloorType(); ILayoutBeams ramBeams = ramFloorType.GetLayoutBeams(); double zStart = bar.StartNode.Position.Z.ToInch() - barStory.dElevation; double zEnd = bar.EndNode.Position.Z.ToInch() - barStory.dElevation; // Get beam fragment cantilever data double startCant = 0; double endCant = 0; bool isStubCant = false; RAMFrameData ramFrameData = bar.FindFragment <RAMFrameData>(typeof(RAMFrameData)); if (ramFrameData != null) { startCant = ramFrameData.StartCantilever; endCant = ramFrameData.EndCantilever; isStubCant = ramFrameData.IsStubCantilever; } if (isStubCant.Equals("True") || isStubCant.Equals("1")) //Check bool per RAM or GH preferred boolean context { SCoordinate startPt, endPt; if (startCant > 0) // Ensure startPt corresponds with support point { startPt = bar.EndNode.Position.ToRAM(); endPt = bar.StartNode.Position.ToRAM(); } else { startPt = bar.StartNode.Position.ToRAM(); endPt = bar.EndNode.Position.ToRAM(); } ramBeam = ramBeams.AddStubCantilever(bar.SectionProperty.Material.ToRAM(), startPt.dXLoc, startPt.dYLoc, 0, endPt.dXLoc, endPt.dYLoc, 0); // No Z offsets, beams flat on closest story } else { // Get support points Vector barDir = bar.Tangent(true); Point startSupPt = BH.Engine.Geometry.Modify.Translate(bar.StartNode.Position, barDir * startCant); Point endSupPt = BH.Engine.Geometry.Modify.Translate(bar.EndNode.Position, -barDir * endCant); SCoordinate start = startSupPt.ToRAM(); SCoordinate end = endSupPt.ToRAM(); ramBeam = ramBeams.Add(bar.SectionProperty.Material.ToRAM(), start.dXLoc, start.dYLoc, 0, end.dXLoc, end.dYLoc, 0); // No Z offsets, beams flat on closest story if (startSupPt.X < endSupPt.X || (startSupPt.X == endSupPt.X && startSupPt.Y > endSupPt.Y)) { ramBeam.dStartCantilever = startCant.FromInch(); ramBeam.dEndCantilever = endCant.FromInch(); } else { ramBeam.dStartCantilever = endCant.FromInch(); ramBeam.dEndCantilever = startCant.FromInch(); } } // Add warning to report distance of snapping to level as required for RAM if (zStart != 0 || zEnd != 0) { Engine.Base.Compute.RecordWarning("Bar " + name + " snapped to level " + barStory.strLabel + ". Bar moved " + Math.Round(zStart, 2).ToString() + " inches at start and " + Math.Round(zEnd, 2).ToString() + " inches at end."); } IBeams beamsOnStory = barStory.GetBeams(); IBeam beam = beamsOnStory.Get(ramBeam.lUID); beam.strSectionLabel = bar.SectionProperty.Name; // beam.EAnalyzeFlag = EAnalyzeFlag.eAnalyze; deprecated in API RAMId.Id = beam.lUID; bar.SetAdapterId(RAMId); } catch { CreateElementError("bar", name); } } //Create columns at each story with offset per actual height foreach (Bar bar in barCols) { string name = bar.Name; try { RAMId RAMId = new RAMId(); IStory barStory = bar.GetStory(StructuralUsage1D.Column, ramStories); List <Node> colNodes = new List <Node>() { bar.StartNode, bar.EndNode }; colNodes.Sort((x, y) => x.Position.Z.CompareTo(y.Position.Z)); double xBtm = colNodes[0].Position.X.ToInch(); double yBtm = colNodes[0].Position.Y.ToInch(); double zBtm = colNodes[0].Position.Z.ToInch() - barStory.dElevation; double xTop = colNodes[1].Position.X.ToInch(); double yTop = colNodes[1].Position.Y.ToInch(); double zTop = colNodes[1].Position.Z.ToInch() - barStory.dElevation + barStory.dFlrHeight; IFloorType ramFloorType = barStory.GetFloorType(); ILayoutColumns ramColumns = ramFloorType.GetLayoutColumns(); ILayoutColumn ramColumn; // Get RAM column data bool isHanging = false; RAMFrameData ramFrameData = bar.FindFragment <RAMFrameData>(typeof(RAMFrameData)); if (ramFrameData != null) { isHanging = ramFrameData.IsHangingColumn; } if (isHanging.Equals("True") || isHanging.Equals("1")) //Check bool per RAM or GH preferred boolean context { ramColumn = ramColumns.Add3(bar.SectionProperty.Material.ToRAM(), xBtm, yBtm, xTop, yTop, 0, 0, 1); //No Z offsets, cols start and end at stories } else if (bar.IsVertical()) { //Failing if no section property is provided ramColumn = ramColumns.Add(bar.SectionProperty.Material.ToRAM(), xTop, yTop, 0, 0); //No Z offsets, cols start and end at stories } else { ramColumn = ramColumns.Add2(bar.SectionProperty.Material.ToRAM(), xTop, yTop, xBtm, yBtm, 0, 0); //No Z offsets, cols start and end at stories } //Set column properties IColumns colsOnStory = barStory.GetColumns(); IColumn column = colsOnStory.Get(ramColumn.lUID); column.strSectionLabel = bar.SectionProperty.Name; column.EAnalyzeFlag = EAnalyzeFlag.eAnalyze; RAMId.Id = column.lUID; bar.SetAdapterId(RAMId); } catch { CreateElementError("bar", name); } } //Save file m_IDBIO.SaveDatabase(); return(true); }
/***************************************************/ /**** Private methods ****/ /***************************************************/ private bool CreateCollection(IEnumerable <Grid> bhomGrid) { // Register GridSystems IGridSystems ramGridSystems = m_Model.GetGridSystems(); // Register FloorTypes IFloorTypes ramFloorTypes = m_Model.GetFloorTypes(); // initializa a BhoM grid List <Grid> Grids = bhomGrid.ToList(); //Split grids by gridtypes List <Grid> XGrids = new List <Grid>(); List <Grid> YGrids = new List <Grid>(); List <Grid> skewGrids = new List <Grid>(); List <Grid> circGrids = new List <Grid>(); Grid grid = new Grid(); Polyline gridLine = new Polyline(); //create different names for the gridSystem based on if there are items in the list double gridSystemRotation = 0; string gridSystemLabel = ""; IGridSystem ramGridSystemXY = null; //IGridSystem ramGridSystemRad = null; //IGridSystem ramGridSystemSk = null; IModelGrids ramModelGridsXY = null; //IModelGrids ramModelGridsRad = null; //IModelGrids ramModelGridsSk = null; //Loop through the BHoM grids and sort per type (x,y,radial, circular, skewed) for (int i = 0; i < Grids.Count(); i++) { grid = Grids[i]; if (grid.Curve is Circle) { circGrids.Add(grid); } else { gridLine = Engine.Geometry.Modify.CollapseToPolyline(grid.Curve as dynamic, 10); //add lines to corresponding lists (XGrids, YGrids) based on their orientation if (Math.Abs(gridLine.StartPoint().X - gridLine.EndPoint().X) < 0.1) { YGrids.Add(grid); } else if (Math.Abs(gridLine.StartPoint().Y - gridLine.EndPoint().Y) < 0.1) { XGrids.Add(grid); } else { skewGrids.Add(grid); } } } //Create grid systems per grid lists //XYGrids if (YGrids.Count() != 0 || XGrids.Count() != 0) { gridSystemLabel = "XY_grid"; ramGridSystemXY = ramGridSystems.Add(gridSystemLabel); ramGridSystemXY.eOrientationType = SGridSysType.eGridOrthogonal; ramGridSystemXY.dRotation = gridSystemRotation; ramModelGridsXY = ramGridSystemXY.GetGrids(); } // NOTE: Radial and Skewed Not Yet Implemented but code framework is below ////Radial Circular Grid //if (circGrids.Count() != 0) //{ // gridSystemLabel = "Radial_grid"; // ramGridSystemRad = ramGridSystems.Add(gridSystemLabel); // ramGridSystemRad.dXOffset = gridOffsetX; // ramGridSystemRad.dYOffset = gridOffsetY; // ramGridSystemRad.eOrientationType = SGridSysType.eGridRadial; // ramGridSystemRad.dRotation = gridSystemRotation; // ramModelGridsRad = ramGridSystemRad.GetGrids(); //} //// Skewed grid //if (skewGrids.Count() != 0) { // gridSystemLabel = "Skew_gird"; // ramGridSystemSk = ramGridSystems.Add(gridSystemLabel); // ramGridSystemSk.dXOffset = 0; // ramGridSystemSk.dYOffset = 0; // ramGridSystemSk.eOrientationType = SGridSysType.eGridSkewed; // ramGridSystemSk.dRotation = gridSystemRotation; // ramModelGridsSk = ramGridSystemSk.GetGrids(); //} // Get Grid System Offset double minY = XGrids[0].Curve.IStartPoint().Y.ToInch(); double minX = YGrids[0].Curve.IStartPoint().X.ToInch(); foreach (Grid XGrid in XGrids) { double gridY = XGrid.Curve.IStartPoint().Y.ToInch(); if (gridY < minY) { minY = gridY; } } foreach (Grid YGrid in YGrids) { double gridX = YGrid.Curve.IStartPoint().X.ToInch(); if (gridX < minX) { minX = gridX; } } ramGridSystemXY.dXOffset = minX; ramGridSystemXY.dYOffset = minY; // Create Grids in GridSystem foreach (Grid XGrid in XGrids) { gridLine = Engine.Geometry.Modify.CollapseToPolyline(XGrid.Curve as dynamic, 10); ramModelGridsXY.Add(XGrid.Name, EGridAxis.eGridYorCircularAxis, gridLine.StartPoint().Y.ToInch() - minY); } foreach (Grid YGrid in YGrids) { gridLine = Engine.Geometry.Modify.CollapseToPolyline(YGrid.Curve as dynamic, 10); ramModelGridsXY.Add(YGrid.Name, EGridAxis.eGridXorRadialAxis, gridLine.StartPoint().X.ToInch() - minX); } foreach (Grid cGrid in circGrids) { // TODO: add code to implement circular grids // Create GridSystem in RAM for each unique centerpt of circGrids } foreach (Grid skGrid in skewGrids) { // TODO: add code to implement skewed grids // Create GridSystem in RAM for each unique angle of skewGrids } //get the ID of the gridsystem int gridSystemID = ramGridSystemXY.lUID; //Cycle through floortypes, access the existing floortype/story, place grids on those stories for (int i = 0; i < ramFloorTypes.GetCount(); i++) { IFloorType ramFloorType = ramFloorTypes.GetAt(i); DAArray gsID = ramFloorType.GetGridSystemIDArray(); gsID.Add(ramGridSystemXY.lUID, 0); ramFloorType.SetGridSystemIDArray(gsID); } //Save file m_IDBIO.SaveDatabase(); return(true); }