Exemplo n.º 1
0
        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);
        }
Exemplo n.º 2
0
        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);
        }
Exemplo n.º 4
0
        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);
        }
Exemplo n.º 7
0
        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);
        }
Exemplo n.º 8
0
 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);
        }