/***************************************************/
/**** 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);
}
