public static Space assignSimpleDefaults(Space zespace, int zonecount)
        {
            CultureInfo ci = new CultureInfo(String.Empty);

            try
            {
                //area and volume should already be computed
                //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-" + zonecount;

                zespace.peoplenum = zespace.Area / 150;
                PeopleNumber pn = new PeopleNumber();
                pn.unit              = peopleNumberUnitEnum.NumberOfPeople;
                pn.valuefield        = (zespace.Area / 150).ToString();
                zespace.PeopleNumber = pn;

                zespace.PeopleHeatGains = new PeopleHeatGain[3];

                zespace.totalpeoplegain = 450;
                PeopleHeatGain tph = new PeopleHeatGain();
                tph.heatGainType           = peopleHeatGainTypeEnum.Total;
                tph.unit                   = peopleHeatGainUnitEnum.BtuPerHourPerson;
                tph.value                  = string.Format(ci, "{0:0.000000}", "450");
                zespace.PeopleHeatGains[0] = tph;

                zespace.senspeoplegain = 250;
                PeopleHeatGain sph = new PeopleHeatGain();
                sph.heatGainType           = peopleHeatGainTypeEnum.Sensible;
                sph.unit                   = peopleHeatGainUnitEnum.BtuPerHourPerson;
                sph.value                  = string.Format(ci, "{0:0.000000}", "250");
                zespace.PeopleHeatGains[1] = sph;

                zespace.latpeoplegain = 200;
                PeopleHeatGain lph = new PeopleHeatGain();
                lph.heatGainType           = peopleHeatGainTypeEnum.Latent;
                lph.unit                   = peopleHeatGainUnitEnum.BtuPerHourPerson;
                lph.value                  = string.Format(ci, "{0:0.000000}", "200");
                zespace.PeopleHeatGains[2] = lph;

                zespace.lpd = 1.2;
                LightPowerPerArea lp = new LightPowerPerArea();
                lp.unit = powerPerAreaUnitEnum.WattPerSquareFoot;
                lp.lpd  = string.Format(ci, "{0:0.000000}", "1.2");
                zespace.LightPowerPerArea = lp;

                zespace.epd = 1.5;
                EquipPowerPerArea ep = new EquipPowerPerArea();
                ep.unit = powerPerAreaUnitEnum.WattPerSquareFoot;
                ep.epd  = string.Format(ci, "{0:0.000000}", "1.5");
                zespace.EquipPowerPerArea = ep;

                Area a = new Area();
                a.val             = string.Format(ci, "{0:0.000000}", zespace.Area.ToString());
                zespace.spacearea = a;

                Volume v = new Volume();
                v.val            = string.Format(ci, "{0:0.000000}", zespace.Volume.ToString());
                zespace.spacevol = v;


                //everything is prepared for geometry
                zespace.PlanarGeo = new PlanarGeometry();
                zespace.ShellGeo  = new ShellGeometry();
                return(zespace);
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        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);
        }