honeybee-core 1.62.6__tar.gz → 1.62.8__tar.gz

{honeybee_core-1.62.6/honeybee_core.egg-info → honeybee_core-1.62.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: honeybee-core
-Version: 1.62.6
+Version: 1.62.8
 Summary: A library to create 3D building geometry for various types of environmental simulation.
 Home-page: https://github.com/ladybug-tools/honeybee-core
 Author: Ladybug Tools

{honeybee_core-1.62.6 → honeybee_core-1.62.8}/honeybee/room.py

@@ -2031,6 +2031,80 @@ class Room(_BaseWithShade):
         self._geometry = room_polyface
         return new_faces
 
+    @staticmethod
+    def join_adjacent_rooms(rooms, tolerance=0.01):
+        """Get Rooms merged across their adjacent Surface boundary conditions.
+
+        When the input rooms form a continuous volume across their adjacencies,
+        a list with only a single joined Room will be returned. Otherwise, there
+        will be more than one Room in the result for each contiguous volume
+        across the adjacencies.
+
+        In all cases, the Room with the highest volume in the contiguous group
+        will set the properties of the joined Room, including multiplier, zone,
+        story, exclude_floor_area, and all extension attributes
+
+        Args:
+            rooms: A list of Rooms which will be merged into one (or more) Rooms
+                across their adjacent Faces.
+            tolerance: The minimum difference between the coordinate values of two
+                faces at which they can be considered adjacent. (Default: 0.01,
+                suitable for objects in meters).
+        """
+        # group the rooms according to their adjacency
+        adj_groups = Room.group_by_adjacency(rooms)
+        joined_rooms = []
+
+        # create the joined Rooms from each group
+        for adj_group in adj_groups:
+            # first check to see if the group has any adjacencies at all
+            if len(adj_group) == 1:
+                joined_rooms.append(adj_group[0])
+                continue
+            # determine the primary room that will set the properties of the new Room
+            volumes = [r.volume for r in adj_group]
+            sort_inds = [i for _, i in sorted(zip(volumes, range(len(volumes))))]
+            primary_room = adj_group[sort_inds[-1]]
+            # gather all of the adjacent faces to be eliminated in the new Room
+            all_adjacencies, remove_faces = {}, set()
+            for room in adj_group:
+                for face in room.faces:
+                    if isinstance(face.boundary_condition, Surface):
+                        bc_obj = face.boundary_condition.boundary_condition_object
+                        all_adjacencies[bc_obj] = face.identifier
+                        if face.identifier in all_adjacencies:
+                            remove_faces.add(face.identifier)
+                            remove_faces.add(all_adjacencies[face.identifier])
+            # gather the faces forming a contiguous volume and make the new room
+            new_faces, new_indoor_shades, new_outdoor_shades = [], [], []
+            for room in adj_group:
+                new_indoor_shades.extend((s.duplicate() for s in room.indoor_shades))
+                new_outdoor_shades.extend((s.duplicate() for s in room.outdoor_shades))
+                for face in room.faces:
+                    if face.identifier not in remove_faces:
+                        new_faces.append(face.duplicate())
+            # create the new room and assign any shades
+            new_r = Room(primary_room.identifier, new_faces, tolerance)
+            new_r._outdoor_shades = new_outdoor_shades
+            new_r._indoor_shades = new_indoor_shades
+            for oshd in new_outdoor_shades:
+                oshd._parent = new_r
+            for ishd in new_indoor_shades:
+                ishd._parent = new_r
+                ishd._is_indoor = True
+            # transfer the primary room properties to the new room
+            new_r._display_name = primary_room._display_name
+            new_r._user_data = None if primary_room.user_data is None \
+                else primary_room.user_data.copy()
+            new_r._multiplier = primary_room.multiplier
+            new_r._zone = primary_room._zone
+            new_r._story = primary_room._story
+            new_r._exclude_floor_area = primary_room.exclude_floor_area
+            new_r._properties._duplicate_extension_attr(primary_room._properties)
+            joined_rooms.append(new_r)
+
+        return joined_rooms
+
     @staticmethod
     def intersect_adjacency(rooms, tolerance=0.01, angle_tolerance=1):
         """Intersect the Faces of an array of Rooms to ensure matching adjacencies.
@@ -2339,6 +2413,49 @@ class Room(_BaseWithShade):
                 floor_heights.append(flrh)
         return grouped_rooms, floor_heights
 
+    @staticmethod
+    def group_by_story(rooms):
+        """Group Rooms according to their story property.
+
+        The returned room groups will be sorted from the lowest average floor
+        to the highest average floor height.
+
+        Args:
+            rooms: A list of honeybee rooms to be grouped by story.
+
+        Returns:
+            A tuple with three items.
+
+            -   grouped_rooms - A list of lists of honeybee rooms with each sub-list
+                representing a different story.
+
+            -   story_names - A list of story names with one value for each
+                sub-list of the output grouped_rooms.
+
+            -   floor_heights - A list of floor heights with one floor height
+                for each sub-list of the output grouped_rooms.
+        """
+        # group the rooms by story
+        story_dict = {}
+        for room in rooms:
+            try:
+                story_dict[room.story].append(room)
+            except KeyError:
+                story_dict[room.story] = [room]
+        # sort the stories by average floor height
+        grouped_rooms, story_names, floor_heights = [], [], []
+        for s_name, g_rooms in story_dict.items():
+            grouped_rooms.append(g_rooms)
+            story_names.append(s_name)
+            weighted_sum = sum(r.average_floor_height * r.floor_area for r in g_rooms)
+            total_area = sum(r.floor_area for r in g_rooms)
+            avg_flr = weighted_sum / total_area
+            floor_heights.append(avg_flr)
+        zip_obj = zip(floor_heights, grouped_rooms, story_names)
+        floor_heights, grouped_rooms, story_names = \
+            (list(t) for t in zip(*sorted(zip_obj, key=lambda x: x[0])))
+        return grouped_rooms, story_names, floor_heights
+
     @staticmethod
     def stories_by_floor_height(rooms, min_difference=2.0):
         """Assign story properties to a set of Rooms using their floor heights.
@@ -3158,7 +3275,7 @@ class Room(_BaseWithShade):
         # loop through the rooms and find air boundary adjacencies
         for room in all_rooms:
             adj_ids = adj_finding_function(room)
-            if len(adj_ids) == 0:  # a room that is its own solar enclosure
+            if len(adj_ids) == 0:  # a room with no adjacencies
                 adj_network.append([room])
             else:  # there are other adjacent rooms to find
                 local_network = [room]

{honeybee_core-1.62.6 → honeybee_core-1.62.8/honeybee_core.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: honeybee-core
-Version: 1.62.6
+Version: 1.62.8
 Summary: A library to create 3D building geometry for various types of environmental simulation.
 Home-page: https://github.com/ladybug-tools/honeybee-core
 Author: Ladybug Tools

{honeybee_core-1.62.6 → honeybee_core-1.62.8}/tests/room_test.py

@@ -605,6 +605,47 @@ def test_find_adjacency():
     assert len(adj_faces[0]) == 2
 
 
+def test_join_adjacent_rooms():
+    """Test the join_adjacent_rooms method."""
+    pts_1 = (Point3D(0, 0), Point3D(15, 0), Point3D(10, 5), Point3D(5, 5))
+    pts_2 = (Point3D(15, 0), Point3D(15, 15), Point3D(10, 10), Point3D(10, 5))
+    pts_3 = (Point3D(0, 15), Point3D(5, 10), Point3D(10, 10), Point3D(15, 15))
+    pts_4 = (Point3D(0, 0), Point3D(5, 5), Point3D(5, 10), Point3D(0, 15))
+    pts_5 = (Point3D(5, 5), Point3D(10, 5), Point3D(10, 10), Point3D(5, 10))
+    pf_1 = Polyface3D.from_offset_face(Face3D(pts_1), 3)
+    pf_2 = Polyface3D.from_offset_face(Face3D(pts_2), 3)
+    pf_3 = Polyface3D.from_offset_face(Face3D(pts_3), 3)
+    pf_4 = Polyface3D.from_offset_face(Face3D(pts_4), 3)
+    pf_5 = Polyface3D.from_offset_face(Face3D(pts_5), 3)
+    room_1 = Room.from_polyface3d('Zone1', pf_1)
+    room_2 = Room.from_polyface3d('Zone2', pf_2)
+    room_3 = Room.from_polyface3d('Zone3', pf_3)
+    room_4 = Room.from_polyface3d('Zone4', pf_4)
+    room_5 = Room.from_polyface3d('Zone5', pf_5)
+
+    rooms = [room_1, room_2, room_3, room_4, room_5]
+    rooms_basement = [rm.duplicate() for rm in rooms]
+    for rm in rooms_basement:
+        rm.move(Vector3D(0, 0, -3))
+        rm.add_prefix('Basement')
+    Room.solve_adjacency(rooms, 0.01)
+    rooms_flr_2 = [rm.duplicate() for rm in rooms]
+    for rm in rooms_flr_2:
+        rm.move(Vector3D(0, 0, 3))
+        rm.add_prefix('Floor2')
+    all_rooms = rooms + rooms_flr_2 + rooms_basement
+
+    joined_rooms = Room.join_adjacent_rooms(all_rooms)
+
+    assert len(joined_rooms) == 7
+    for r in joined_rooms:
+        assert isinstance(r, Room)
+    assert sum(r.volume for r in joined_rooms) == \
+        pytest.approx(sum(r.volume for r in all_rooms), rel=1e-3)
+    assert sum(r.floor_area for r in joined_rooms) == \
+        pytest.approx(sum(r.floor_area for r in all_rooms), rel=1e-3)
+
+
 def test_group_by_adjacency():
     """Test the group_by_adjacency method."""
     pts_1 = (Point3D(0, 0), Point3D(15, 0), Point3D(10, 5), Point3D(5, 5))
@@ -714,6 +755,41 @@ def test_group_by_orientation():
     assert orientations == [0.0, 90.0, 180.0, 270.0]
 
 
+def test_group_by_story():
+    """Test the group_by_story method."""
+    pts_1 = (Point3D(0, 0), Point3D(15, 0), Point3D(10, 5), Point3D(5, 5))
+    pts_2 = (Point3D(15, 0), Point3D(15, 15), Point3D(10, 10), Point3D(10, 5))
+    pts_3 = (Point3D(0, 15), Point3D(5, 10), Point3D(10, 10), Point3D(15, 15))
+    pts_4 = (Point3D(0, 0), Point3D(5, 5), Point3D(5, 10), Point3D(0, 15))
+    pts_5 = (Point3D(5, 5), Point3D(10, 5), Point3D(10, 10), Point3D(5, 10))
+    pf_1 = Polyface3D.from_offset_face(Face3D(pts_1), 3)
+    pf_2 = Polyface3D.from_offset_face(Face3D(pts_2), 3)
+    pf_3 = Polyface3D.from_offset_face(Face3D(pts_3), 3)
+    pf_4 = Polyface3D.from_offset_face(Face3D(pts_4), 3)
+    pf_5 = Polyface3D.from_offset_face(Face3D(pts_5), 3)
+    room_1 = Room.from_polyface3d('Zone1', pf_1)
+    room_2 = Room.from_polyface3d('Zone2', pf_2)
+    room_3 = Room.from_polyface3d('Zone3', pf_3)
+    room_4 = Room.from_polyface3d('Zone4', pf_4)
+    room_5 = Room.from_polyface3d('Zone5', pf_5)
+    rooms = [room_1, room_2, room_3, room_4, room_5]
+    for rm in rooms:
+        rm.story = 'Ground Floor'
+
+    rooms_basement = [rm.duplicate() for rm in rooms]
+    for rm in rooms_basement:
+        rm.move(Vector3D(0, 0, -3))
+        rm.add_prefix('Basement')
+        rm.story = 'Basement'
+    Room.solve_adjacency(rooms, 0.01)
+    all_rooms = rooms + rooms_basement
+
+    grouped_rooms, story_names, floor_heights = Room.group_by_story(all_rooms)
+    assert floor_heights == [-3.0, 0.0]
+    assert story_names == ['Basement', 'Ground Floor']
+    assert len(grouped_rooms[0]) == 5
+
+
 def test_horizontal_boundary():
     """Test the horizontal_boundary method for a variety of shapes."""
     geo_file = './tests/json/complex_polyfaces.json'