public static SpaceBoundary[] SpaceBoundaries(this List <BHE.Panel> spaceBoundaries, List <BHE.Panel> uniqueBEs)
{
List <Polyloop> pLoops = new List <Polyloop>();
List <BHG.Polyline> panels = spaceBoundaries.Select(x => x.Polyline()).ToList();
foreach (BHG.Polyline pLine in panels)
{
if (BH.Engine.Environment.Query.NormalAwayFromSpace(pLine, spaceBoundaries))
{
pLoops.Add(BH.Engine.XML.Convert.ToGBXML(pLine));
}
else
{
pLoops.Add(BH.Engine.XML.Convert.ToGBXML(pLine.Flip()));
}
}
SpaceBoundary[] boundaries = new SpaceBoundary[pLoops.Count];
for (int x = 0; x < pLoops.Count; x++)
{
PlanarGeometry planarGeom = new PlanarGeometry();
planarGeom.PolyLoop = pLoops[x];
planarGeom.ID = "pGeom" + Guid.NewGuid().ToString().Replace("-", "").Substring(0, 10);
boundaries[x] = new SpaceBoundary {
PlanarGeometry = planarGeom
};
//Get the ID from the referenced element
boundaries[x].SurfaceIDRef = "Panel-" + uniqueBEs.FindIndex(i => i.BHoM_Guid == spaceBoundaries[x].BHoM_Guid).ToString();
}
return(boundaries);
}
public static PlanarGeometry TogbXML(this Spatial.IClosedPlanar3D closedPlanar3D, double tolerance = Core.Tolerance.MicroDistance)
{
if (closedPlanar3D == null)
{
return(null);
}
PlanarGeometry planarGeometry = new PlanarGeometry();
planarGeometry.PolyLoop = closedPlanar3D.TogbXML_PolyLoop(tolerance);
return(planarGeometry);
}
//same but from a series of Vector Cartesian Coordinates
public static BuildingStorey MakeStorey(int levelnum, List <Vector.MemorySafe_CartCoord> points)
{
BuildingStorey bs = new BuildingStorey();
bs.id = "bldg-story-" + levelnum;
bs.Name = "Level " + levelnum;
bs.Level = (levelnum - 1).ToString();
//there is only one plane per storey
PlanarGeometry pg = new PlanarGeometry();
//make polyloop with points
pg.PolyLoop = new PolyLoop();
//uses just a simple set of points = List<List<double>>
pg.PolyLoop = prod.MakePolyLoops(pg.PolyLoop, points);
//add polyloop to the building storey object
bs.PlanarGeo = pg;
return(bs);
}
public static PlanarGeometry TogbXML(this PlanarBoundary3D planarBoundary3D, double tolerance = Core.Tolerance.MicroDistance)
{
if (planarBoundary3D == null)
{
return(null);
}
Geometry.Spatial.Face3D face3D = planarBoundary3D.GetFace3D();
if (face3D == null)
{
return(null);
}
PlanarGeometry planarGeometry = new PlanarGeometry();
planarGeometry.PolyLoop = face3D.TogbXML_PolyLoop(tolerance);
return(planarGeometry);
}
public static PlanarGeometry makegbPlanarGeom(List <List <Vector.MemorySafe_CartCoord> > coordinates)
{
PlanarGeometry pg = new PlanarGeometry();
PolyLoop pl = new PolyLoop();
pg.PolyLoop = pl;
for (int i = 0; i < coordinates.Count(); i++)
{
//the polyloop array of points is defined
pl.Points = new CartesianPoint[coordinates[i].Count()];
for (int j = 0; j < coordinates[i].Count(); j++)
{
//returns a point with three coordinate strings
CartesianPoint cp = makegbCartesianPt(coordinates[i][j]);
//the point is added to the polyloop
pl.Points[j] = cp;
}
}
return(pg);
}
public static List <BuildingStorey> MakeStories(List <List <Vector.MemorySafe_CartCoord> > pointslist)
{
List <BuildingStorey> stories = new List <BuildingStorey>();
for (int i = 1; i <= pointslist.Count(); i++)
{
BuildingStorey bs = new BuildingStorey();
bs.id = "bldg-story-" + i;
bs.Name = "Level " + i;
bs.Level = (i - 1).ToString();
//there is only one plane per storey
PlanarGeometry pg = new PlanarGeometry();
//make polyloop with points
pg.PolyLoop = new PolyLoop();
//uses just a simple set of points = List<List<double>>
pg.PolyLoop = prod.MakePolyLoops(pg.PolyLoop, pointslist[i]);
//add polyloop to the building storey object
bs.PlanarGeo = pg;
stories.Add(bs);
}
return(stories);
}
static public Surface SetUpSurfaceFromIDF(EPObj.MemorySafe_Surface epsurface, PlanarGeometry pg)
{
Surface retsurface = new Surface();
retsurface.PlanarGeometry = pg;
if (epsurface._sunExposureVar == "SunExposed")
{
retsurface.AdjacentSpaceId = new AdjacentSpaceId[1];
if (epsurface.tilt > 45 && epsurface.tilt < 135)
{
Dictionary <string, double> WH = new Dictionary <string, double>();
//it can be considered an exterior wall
retsurface.surfaceType = surfaceTypeEnum.ExteriorWall;
retsurface.constructionIdRef = "something";
retsurface.Name = epsurface.name;
AdjacentSpaceId adj = new AdjacentSpaceId();
adj.spaceIdRef = epsurface.zoneName;
retsurface.AdjacentSpaceId[0] = adj;
RectangularGeometry rg = new RectangularGeometry();
rg.Azimuth = gb.FormatDoubleToString(epsurface.azimuth);
//find lower left hand corner of exterior wall
//for now, we will just arbitrarily choose a point
rg.CartesianPoint = pg.PolyLoop.Points[0];
rg.Tilt = gb.FormatDoubleToString(epsurface.tilt);
//get width and height
WH = GetWidthandHeight(epsurface, retsurface.surfaceType);
rg.Width = gb.FormatDoubleToString(WH["width"]);
rg.Height = gb.FormatDoubleToString(WH["height"]);
retsurface.RectangularGeometry = rg;
retsurface.PlanarGeometry = pg;
retsurface.exposedToSunField = true;
}
//it can be a roof
else if (epsurface.tilt >= 0 && epsurface.tilt <= 45)
{
Dictionary <string, double> WH = new Dictionary <string, double>();
//it can be considered an exterior wall
retsurface.surfaceType = surfaceTypeEnum.Roof;
retsurface.constructionIdRef = "something";
retsurface.Name = epsurface.name;
AdjacentSpaceId adj = new AdjacentSpaceId();
adj.spaceIdRef = epsurface.zoneName;
retsurface.AdjacentSpaceId[0] = adj;
RectangularGeometry rg = new RectangularGeometry();
rg.Azimuth = gb.FormatDoubleToString(epsurface.azimuth);
//find lower left hand corner of exterior wall
//for now, we will just arbitrarily choose a point
rg.CartesianPoint = pg.PolyLoop.Points[0];
rg.Tilt = gb.FormatDoubleToString(epsurface.tilt);
//get width and height
WH = GetWidthandHeight(epsurface, retsurface.surfaceType);
rg.Width = gb.FormatDoubleToString(WH["width"]);
rg.Height = gb.FormatDoubleToString(WH["height"]);
retsurface.RectangularGeometry = rg;
retsurface.PlanarGeometry = pg;
retsurface.exposedToSunField = true;
}
//it can be an exposed floor
else
{
Dictionary <string, double> WH = new Dictionary <string, double>();
//it can be considered an exterior wall
retsurface.surfaceType = surfaceTypeEnum.UndergroundSlab;
retsurface.constructionIdRef = "something";
retsurface.Name = epsurface.name;
AdjacentSpaceId adj = new AdjacentSpaceId();
adj.spaceIdRef = epsurface.zoneName;
retsurface.AdjacentSpaceId[0] = adj;
RectangularGeometry rg = new RectangularGeometry();
rg.Azimuth = gb.FormatDoubleToString(epsurface.azimuth);
//find lower left hand corner of exterior wall
//for now, we will just arbitrarily choose a point
rg.CartesianPoint = pg.PolyLoop.Points[0];
rg.Tilt = gb.FormatDoubleToString(epsurface.tilt);
//get width and height
WH = GetWidthandHeight(epsurface, retsurface.surfaceType);
rg.Width = gb.FormatDoubleToString(WH["width"]);
rg.Height = gb.FormatDoubleToString(WH["height"]);
retsurface.RectangularGeometry = rg;
retsurface.PlanarGeometry = pg;
retsurface.exposedToSunField = true;
}
}
else if (epsurface._sunExposureVar == "NoSun" && epsurface._outsideBoundaryCondition == "Ground")
{
if (epsurface.tilt > 45 && epsurface.tilt < 135)
{
Dictionary <string, double> WH = new Dictionary <string, double>();
//it can be considered an underground wall
retsurface.surfaceType = surfaceTypeEnum.UndergroundWall;
retsurface.constructionIdRef = "something";
retsurface.Name = epsurface.name;
AdjacentSpaceId adj1 = new AdjacentSpaceId();
adj1.spaceIdRef = epsurface.zoneName;
AdjacentSpaceId adj2 = new AdjacentSpaceId();
adj2.spaceIdRef = epsurface.zoneName;
retsurface.AdjacentSpaceId[0] = adj1;
retsurface.AdjacentSpaceId[1] = adj2;
RectangularGeometry rg = new RectangularGeometry();
rg.Azimuth = gb.FormatDoubleToString(epsurface.azimuth);
//find lower left hand corner of exterior wall
//for now, we will just arbitrarily choose a point
rg.CartesianPoint = pg.PolyLoop.Points[0];
rg.Tilt = gb.FormatDoubleToString(epsurface.tilt);
//get width and height
WH = GetWidthandHeight(epsurface, retsurface.surfaceType);
rg.Width = gb.FormatDoubleToString(WH["width"]);
rg.Height = gb.FormatDoubleToString(WH["height"]);
retsurface.RectangularGeometry = rg;
retsurface.PlanarGeometry = pg;
retsurface.exposedToSunField = false;
}
else if (epsurface.tilt >= 0 && epsurface.tilt <= 45)
{
Dictionary <string, double> WH = new Dictionary <string, double>();
//it can be considered an underground ceiling
retsurface.surfaceType = surfaceTypeEnum.UndergroundCeiling;
retsurface.constructionIdRef = "something";
retsurface.Name = epsurface.name;
AdjacentSpaceId adj1 = new AdjacentSpaceId();
adj1.spaceIdRef = epsurface.zoneName;
AdjacentSpaceId adj2 = new AdjacentSpaceId();
adj2.spaceIdRef = epsurface.zoneName;
retsurface.AdjacentSpaceId[0] = adj1;
retsurface.AdjacentSpaceId[1] = adj2;
RectangularGeometry rg = new RectangularGeometry();
rg.Azimuth = gb.FormatDoubleToString(epsurface.azimuth);
//find lower left hand corner of exterior wall
//for now, we will just arbitrarily choose a point
rg.CartesianPoint = pg.PolyLoop.Points[0];
rg.Tilt = gb.FormatDoubleToString(epsurface.tilt);
//get width and height
WH = GetWidthandHeight(epsurface, retsurface.surfaceType);
rg.Width = gb.FormatDoubleToString(WH["width"]);
rg.Height = gb.FormatDoubleToString(WH["height"]);
retsurface.RectangularGeometry = rg;
retsurface.PlanarGeometry = pg;
retsurface.exposedToSunField = false;
}
else
{
Dictionary <string, double> WH = new Dictionary <string, double>();
//it can be considered an underground slab or slab on grade
retsurface.surfaceType = surfaceTypeEnum.UndergroundSlab;
retsurface.constructionIdRef = "something";
retsurface.Name = epsurface.name;
AdjacentSpaceId adj1 = new AdjacentSpaceId();
adj1.spaceIdRef = epsurface.zoneName;
AdjacentSpaceId adj2 = new AdjacentSpaceId();
adj2.spaceIdRef = epsurface.zoneName;
retsurface.AdjacentSpaceId[0] = adj1;
retsurface.AdjacentSpaceId[1] = adj2;
RectangularGeometry rg = new RectangularGeometry();
rg.Azimuth = gb.FormatDoubleToString(epsurface.azimuth);
//find lower left hand corner of exterior wall
//for now, we will just arbitrarily choose a point
rg.CartesianPoint = pg.PolyLoop.Points[0];
rg.Tilt = gb.FormatDoubleToString(epsurface.tilt);
//get width and height
WH = GetWidthandHeight(epsurface, retsurface.surfaceType);
rg.Width = gb.FormatDoubleToString(WH["width"]);
rg.Height = gb.FormatDoubleToString(WH["height"]);
retsurface.RectangularGeometry = rg;
retsurface.PlanarGeometry = pg;
retsurface.exposedToSunField = false;
}
}
else
{
retsurface.AdjacentSpaceId = new AdjacentSpaceId[2];
//some new code associated with finding the order of the two spaces
if (epsurface.tilt > 45 && epsurface.tilt < 135)
{
Dictionary <string, double> WH = new Dictionary <string, double>();
//it can be considered an underground wall
retsurface.surfaceType = surfaceTypeEnum.UndergroundWall;
retsurface.constructionIdRef = "something";
retsurface.Name = epsurface.name;
//this is wrong
AdjacentSpaceId adj1 = new AdjacentSpaceId();
adj1.spaceIdRef = epsurface.zoneName;
AdjacentSpaceId adj2 = new AdjacentSpaceId();
adj2.spaceIdRef = epsurface.zoneName;
retsurface.AdjacentSpaceId[0] = adj1;
retsurface.AdjacentSpaceId[1] = adj2;
RectangularGeometry rg = new RectangularGeometry();
rg.Azimuth = gb.FormatDoubleToString(epsurface.azimuth);
//find lower left hand corner of exterior wall
//for now, we will just arbitrarily choose a point
rg.CartesianPoint = pg.PolyLoop.Points[0];
rg.Tilt = gb.FormatDoubleToString(epsurface.tilt);
//get width and height
WH = GetWidthandHeight(epsurface, retsurface.surfaceType);
rg.Width = gb.FormatDoubleToString(WH["width"]);
rg.Height = gb.FormatDoubleToString(WH["height"]);
retsurface.RectangularGeometry = rg;
retsurface.PlanarGeometry = pg;
retsurface.exposedToSunField = false;
}
else if (epsurface.tilt >= 0 && epsurface.tilt <= 45)
{
Dictionary <string, double> WH = new Dictionary <string, double>();
//it can be considered an underground ceiling
retsurface.surfaceType = surfaceTypeEnum.UndergroundCeiling;
retsurface.constructionIdRef = "something";
retsurface.Name = epsurface.name;
//this is wrong
AdjacentSpaceId adj1 = new AdjacentSpaceId();
adj1.spaceIdRef = epsurface.zoneName;
AdjacentSpaceId adj2 = new AdjacentSpaceId();
adj2.spaceIdRef = epsurface.zoneName;
retsurface.AdjacentSpaceId[0] = adj1;
retsurface.AdjacentSpaceId[1] = adj2;
RectangularGeometry rg = new RectangularGeometry();
rg.Azimuth = gb.FormatDoubleToString(epsurface.azimuth);
//find lower left hand corner of exterior wall
//for now, we will just arbitrarily choose a point
rg.CartesianPoint = pg.PolyLoop.Points[0];
rg.Tilt = gb.FormatDoubleToString(epsurface.tilt);
//get width and height
WH = GetWidthandHeight(epsurface, retsurface.surfaceType);
rg.Width = gb.FormatDoubleToString(WH["width"]);
rg.Height = gb.FormatDoubleToString(WH["height"]);
retsurface.RectangularGeometry = rg;
retsurface.PlanarGeometry = pg;
retsurface.exposedToSunField = false;
}
else
{
Dictionary <string, double> WH = new Dictionary <string, double>();
//it can be considered an underground slab or slab on grade
retsurface.surfaceType = surfaceTypeEnum.UndergroundSlab;
retsurface.constructionIdRef = "something";
retsurface.Name = epsurface.name;
//this is wrong
AdjacentSpaceId adj1 = new AdjacentSpaceId();
adj1.spaceIdRef = epsurface.zoneName;
AdjacentSpaceId adj2 = new AdjacentSpaceId();
adj2.spaceIdRef = epsurface.zoneName;
retsurface.AdjacentSpaceId[0] = adj1;
retsurface.AdjacentSpaceId[1] = adj2;
RectangularGeometry rg = new RectangularGeometry();
rg.Azimuth = gb.FormatDoubleToString(epsurface.azimuth);
//find lower left hand corner of exterior wall
//for now, we will just arbitrarily choose a point
rg.CartesianPoint = pg.PolyLoop.Points[0];
rg.Tilt = gb.FormatDoubleToString(epsurface.tilt);
//get width and height
WH = GetWidthandHeight(epsurface, retsurface.surfaceType);
rg.Width = gb.FormatDoubleToString(WH["width"]);
rg.Height = gb.FormatDoubleToString(WH["height"]);
retsurface.RectangularGeometry = rg;
retsurface.PlanarGeometry = pg;
retsurface.exposedToSunField = false;
}
}
return(retsurface);
}
public static Polygon3D ToSAM(this PlanarGeometry planarGeometry, double tolerance = Tolerance.Distance)
{
return(planarGeometry?.PolyLoop?.ToSAM(tolerance));
}
public static List <Space> MakeSpacesFromEPObj(List <EPObj.MemorySafe_Spaces> myspace)
{
List <Space> retspaces = new List <Space>();
int spacecount = 0;
foreach (EPObj.MemorySafe_Spaces space in myspace)
{
//foreach Space space in your ListofSpaces
Space zespace = new Space();
zespace.id = "Space-1";
zespace.lightScheduleIdRef = "lightSchedule-1";
zespace.equipmentScheduleIdRef = "equipmentSchedule-1";
zespace.peopleScheduleIdRef = "peopleSchedule-1";
zespace.conditionType = "HeatedAndCooled";
zespace.buildingStoreyIdRef = "bldg-story-1";
zespace.Name = "Test Space-" + spacecount;
zespace.peoplenum = 12;
zespace.totalpeoplegain = 450;
zespace.senspeoplegain = 250;
zespace.latpeoplegain = 200;
zespace.PeopleHeatGains = new PeopleHeatGain[3];
zespace.lpd = 1.2;
zespace.epd = 1.5;
zespace.Area = 2450;
zespace.Volume = 24500;
zespace.PlanarGeo = new PlanarGeometry();
zespace.ShellGeo = new ShellGeometry();
PeopleNumber pn = new PeopleNumber();
pn.unit = peopleNumberUnitEnum.NumberOfPeople;
string people = gb.FormatDoubleToString(zespace.peoplenum);
pn.valuefield = people;
zespace.PeopleNumber = pn;
PeopleHeatGain phg = new PeopleHeatGain();
phg.unit = peopleHeatGainUnitEnum.BtuPerHourPerson;
phg.heatGainType = peopleHeatGainTypeEnum.Total;
string totalpopload = gb.FormatDoubleToString(zespace.totalpeoplegain);
phg.value = totalpopload;
zespace.PeopleHeatGains[0] = phg;
PeopleHeatGain shg = new PeopleHeatGain();
shg.unit = peopleHeatGainUnitEnum.BtuPerHourPerson;
shg.heatGainType = peopleHeatGainTypeEnum.Sensible;
string senspopload = gb.FormatDoubleToString(zespace.senspeoplegain);
shg.value = senspopload;
zespace.PeopleHeatGains[1] = shg;
PeopleHeatGain lhg = new PeopleHeatGain();
lhg.unit = peopleHeatGainUnitEnum.BtuPerHourPerson;
lhg.heatGainType = peopleHeatGainTypeEnum.Latent;
string latpopload = gb.FormatDoubleToString(zespace.latpeoplegain);
lhg.value = latpopload;
zespace.PeopleHeatGains[2] = lhg;
LightPowerPerArea lpd = new LightPowerPerArea();
lpd.unit = powerPerAreaUnitEnum.WattPerSquareFoot;
lpd.lpd = gb.FormatDoubleToString(zespace.lpd);
zespace.LightPowerPerArea = lpd;
EquipPowerPerArea epd = new EquipPowerPerArea();
epd.unit = powerPerAreaUnitEnum.WattPerSquareFoot;
epd.epd = gb.FormatDoubleToString(zespace.epd);
zespace.EquipPowerPerArea = epd;
Area spacearea = new Area();
spacearea.val = gb.FormatDoubleToString(zespace.Area);
zespace.spacearea = spacearea;
Volume spacevol = new Volume();
spacevol.val = gb.FormatDoubleToString(zespace.Volume);
zespace.spacevol = spacevol;
//same as the planar geometry of the floor planes above
PlanarGeometry spaceplpoly = new PlanarGeometry();
//get a list of points that makes up the polyloop
List <List <double> > spacepoints = prod.MakeFakeList(3);
//make polyloop with points
spaceplpoly.PolyLoop = new PolyLoop();
spaceplpoly.PolyLoop = prod.makePolyLoopsFromDbleList(spaceplpoly.PolyLoop, spacepoints);
zespace.PlanarGeo = spaceplpoly;
//@@
//ShellGeometry
//similar to planar geometry, but with more planes
ShellGeometry sg = new ShellGeometry();
sg.unit = lengthUnitEnum.Feet;
sg.id = "sg" + space.name;
sg.ClosedShell = new ClosedShell();
//up to 100 surfaces per space? base on the space instance surfaces
sg.ClosedShell.PolyLoops = new PolyLoop[space.spaceSurfaces.Count()];
//I would have a list of surface elements that make up the space surfaces.
//each surface would consist of a series of points that defines the surface.
for (int i = 0; i < space.spaceSurfaces.Count(); i++)
{
//get points from the space surfaces
List <List <double> > epluspoints = new List <List <double> >();
epluspoints = EnergyPlusClass.GetCoordinDoubles(space.spaceSurfaces[i].SurfaceCoords);
sg.ClosedShell.PolyLoops[i] = new PolyLoop();
sg.ClosedShell.PolyLoops[i] = prod.makePolyLoopsFromDbleList(sg.ClosedShell.PolyLoops[i], epluspoints);
}
zespace.ShellGeo = sg;
zespace.cadid = new CADObjectId();
zespace.cadid.id = "990099-" + spacecount;
//make surface boundaries..special code needed so that space boundaries are not duplicated...
//option 1 : the surfaces already declared as internal somehow and how shared.
//option 2: the api tries to figure it out
zespace.spbound = new SpaceBoundary[space.spaceSurfaces.Count()];
int psurfacecount = 0;
for (int i = 0; i < space.spaceSurfaces.Count(); i++)
{
//get points from the space surfaces
List <List <double> > epluspoints = new List <List <double> >();
epluspoints = EnergyPlusClass.GetCoordinDoubles(space.spaceSurfaces[i].SurfaceCoords);
//if surface is exterior
SpaceBoundary sb = new SpaceBoundary();
zespace.spbound[i] = prod.MakeSpaceBoundary(sb, epluspoints, psurfacecount);
psurfacecount++;
//else if surface is interior and it has not been listed before
//then do the same
//else do nothing because it is interior and it has already been listed
//I also would like to keep track of all the surfaces that I create to better prepare me for the surface definition
uniquesurf.Add(zespace.spbound[i].PlanarGeometry);
//make a dictionary that stores the name of a surface and its planar geometry?
uniqueplanes.Add(zespace.spbound[i].surfaceIdRef, zespace.spbound[i].PlanarGeometry);
//make a dictionary that stores the name of a surface and create a surface as the value
Surface newsurface = new Surface();
//this took a lot of customization...a user would have to make their own code to attach to my object here
newsurface = prod.SetUpSurfaceFromIDF(space.spaceSurfaces[i], zespace.spbound[i].PlanarGeometry);
uniquesurfaces.Add(zespace.spbound[i].surfaceIdRef, newsurface);
}
retspaces.Add(zespace);
spacecount++;
}
return(retspaces);
}
