/***************************************************/
public static IStory GetStory(this Panel panel, IStories ramStories)
{
double elev;
List <double> panelHeights = new List <double>();
List <Point> panelPoints = new List <Point>();
// Get heights of wall and floor corners to create levels
PolyCurve panelOutline = Engine.Spatial.Query.OutlineCurve(panel);
panelPoints = panelOutline.DiscontinuityPoints();
foreach (Point pt in panelPoints)
{
panelHeights.Add(Math.Round(pt.Z, 0));
}
// Get elevation of panel per max elevation
elev = panelHeights.Max().ToInch();
//There must be a better way to iterate over IStories
List <IStory> storeys = new List <IStory>();
int numStories = ramStories.GetCount();
for (int i = 0; i < numStories; i++)
{
storeys.Add(ramStories.GetAt(i));
}
return(storeys.OrderBy(x => Math.Abs(x.dElevation - elev)).First());
}
/***************************************************/
/**** 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);
}
/***************************************************/
public static IStory GetStory(this Point point, IStories ramStories)
{
double elev = point.Z.ToInch();
//There must be a better way to iterate over IStories
List <IStory> storeys = new List <IStory>();
int numStories = ramStories.GetCount();
for (int i = 0; i < numStories; i++)
{
storeys.Add(ramStories.GetAt(i));
}
return(storeys.OrderBy(x => Math.Abs(x.dElevation - elev)).First());
}
/***************************************************/
/**** Private methods ****/
/***************************************************/
private List <Level> ReadLevel(List <string> ids = null)
{
//Implement code for reading Levels
List <Level> bhomLevels = new List <Level>();
// Get the levels that are in the model
IStories stories = m_Model.GetStories();
int numStories = stories.GetCount();
for (int i = 0; i < numStories; i++)
{
bhomLevels.Add(stories.GetAt(i).ToBHoMObject());
}
return(bhomLevels);
}
/***************************************************/
public static IStory GetStory(this Bar bar, StructuralUsage1D usage1D, IStories ramStories)
{
double elev;
switch (usage1D)
{
case StructuralUsage1D.Beam:
//Use lowest end elevation
elev = Math.Min(bar.StartNode.Position.Z, bar.EndNode.Position.Z).ToInch();
break;
case StructuralUsage1D.Column:
// 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")) //Hanging Column to be placed on its btm level.
{
elev = Math.Min(bar.StartNode.Position.Z, bar.EndNode.Position.Z).ToInch();
}
else //Column to be placed on the level it supports.
{
elev = Math.Max(bar.StartNode.Position.Z, bar.EndNode.Position.Z).ToInch();
}
break;
default:
//Use lowest end elevation
elev = Math.Min(bar.StartNode.Position.Z, bar.EndNode.Position.Z).ToInch();
break;
}
//There must be a better way to iterate over IStories
List <IStory> storeys = new List <IStory>();
int numStories = ramStories.GetCount();
for (int i = 0; i < numStories; i++)
{
storeys.Add(ramStories.GetAt(i));
}
return(storeys.OrderBy(x => Math.Abs(x.dElevation - elev)).First());
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static List <double> ToLevelElevations(this IModel ramModel)
{
List <double> RAMLevelHeights = new List <double>();
//Get existing levels
List <string> FloorTypeNames = new List <string>();
List <string> StoryNames = new List <string>();
double StoryElevation;
IFloorTypes IFloorTypes = ramModel.GetFloorTypes();
IStories IStories = ramModel.GetStories();
double storyCount = IStories.GetCount();
for (int i = 0; i < storyCount; i++)
{
StoryElevation = IStories.GetAt(i).dElevation.FromInch();
RAMLevelHeights.Add(StoryElevation);
}
return(RAMLevelHeights);
}
/***************************************************/
private List <IWall> ReadRamWalls(IModel ramModel)
{
//Get stories
IStories ramStories = ramModel.GetStories();
int numStories = ramStories.GetCount();
List <IWall> allRamWalls = new List <IWall>();
// Get all walls on each story
for (int i = 0; i < numStories; i++)
{
//Get Walls
IWalls ramWalls = ramStories.GetAt(i).GetWalls();
int numWalls = ramWalls.GetCount();
// Convert Walls
for (int j = 0; j < numWalls; j++)
{
IWall ramWall = ramWalls.GetAt(j);
allRamWalls.Add(ramWall);
}
}
return(allRamWalls);
}
/***************************************************/
private List <IBeam> ReadRamBeams(IModel ramModel)
{
//Get stories
IStories ramStories = ramModel.GetStories();
int numStories = ramStories.GetCount();
List <IBeam> allRamBeams = new List <IBeam>();
// Get all beams on each story
for (int i = 0; i < numStories; i++)
{
//Get beams
IBeams ramBeams = ramStories.GetAt(i).GetBeams();
int numBeams = ramBeams.GetCount();
// Convert beams
for (int j = 0; j < numBeams; j++)
{
IBeam ramBeam = ramBeams.GetAt(j);
allRamBeams.Add(ramBeam);
}
}
return(allRamBeams);
}
/***************************************************/
/**** 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);
}
