topologicpy 0.8.12__py3-none-any.whl → 0.8.14__py3-none-any.whl

topologicpy/Cell.py

@@ -2185,62 +2185,154 @@ class Cell():
         return Cell.Area(cell=cell, mantissa=mantissa)
     
     @staticmethod
-    def Tetrahedron(origin= None, radius: float = 0.5,
-                  direction: list = [0, 0, 1], placement: str ="center", tolerance: float = 0.0001):
+    def Tetrahedron(origin = None, length: float = 1, depth: int = 1, direction=[0,0,1], placement="center", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
         """
-        Creates a tetrahedron. See https://en.wikipedia.org/wiki/Tetrahedron.
+        Creates a recursive tetrahedron cell.
 
         Parameters
         ----------
         origin : topologic_core.Vertex , optional
             The origin location of the tetrahedron. The default is None which results in the tetrahedron being placed at (0, 0, 0).
-        radius : float , optional
-            The radius of the tetrahedron's circumscribed sphere. The default is 0.5.
+        length : float , optional
+            The length of the edge of the tetrahedron. The default is 1.
+        depth : int , optional
+            The desired maximum number of recrusive subdivision levels.
         direction : list , optional
             The vector representing the up direction of the tetrahedron. The default is [0, 0, 1].
         placement : str , optional
             The description of the placement of the origin of the tetrahedron. This can be "bottom", "center", or "lowerleft". It is case insensitive. The default is "center".
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         
         Returns
         -------
-        topologic_core.Cell
+        topologic_core.CellComplex
             The created tetrahedron.
 
         """
-        
         from topologicpy.Vertex import Vertex
-        from topologicpy.Wire import Wire
         from topologicpy.Face import Face
+        from topologicpy.Cell import Cell
+        from topologicpy.CellComplex import CellComplex
+        from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
-        import math
+        from topologicpy.Dictionary import Dictionary
 
-        if not Topology.IsInstance(origin, "Vertex"):
-            origin = Vertex.ByCoordinates(0, 0, 0)
-        if not Topology.IsInstance(origin, "Vertex"):
-            print("Cell.Tetrahedron - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
-            return None
+        from math import sqrt
 
-        vb1 = Vertex.ByCoordinates(math.sqrt(8/9), 0, -1/3)
-        vb2 = Vertex.ByCoordinates(-math.sqrt(2/9), math.sqrt(2/3), -1/3)
-        vb3 = Vertex.ByCoordinates(-math.sqrt(2/9), -math.sqrt(2/3), -1/3)
-        vb4 = Vertex.ByCoordinates(0, 0, 1)
-        f1 = Face.ByVertices([vb1, vb2, vb3])
-        f2 = Face.ByVertices([vb4, vb1, vb2])
-        f3 = Face.ByVertices([vb4, vb2, vb3])
-        f4 = Face.ByVertices([vb4, vb3, vb1])
-        tetrahedron = Cell.ByFaces([f1, f2, f3, f4])
-        tetrahedron = Topology.Scale(tetrahedron, origin=Vertex.Origin(), x=0.5, y=0.5, z=0.5)
-        tetrahedron = Topology.Scale(tetrahedron, origin=Vertex.Origin(), x=radius/0.5, y=radius/0.5, z=radius/0.5)
+        def subdivide_tetrahedron(tetrahedron, depth):
+            """
+            Recursively subdivides a tetrahedron into smaller tetrahedra.
 
-        if placement.lower() == "lowerleft":
-            tetrahedron = Topology.Translate(tetrahedron, radius, radius, radius)
+            Parameters:
+                tetrahedron (Cell): The tetrahedron to subdivide.
+                depth (int): Recursion depth for the subdivision.
+
+            Returns:
+                list: List of smaller tetrahedral cells.
+            """
+            if depth == 0:
+                return [tetrahedron]
+
+            # Extract the vertices of the tetrahedron
+            vertices = Topology.Vertices(tetrahedron)
+            v0, v1, v2, v3 = vertices
+
+            # Calculate midpoints of the edges
+            m01 = Vertex.ByCoordinates((v0.X() + v1.X()) / 2, (v0.Y() + v1.Y()) / 2, (v0.Z() + v1.Z()) / 2)
+            m02 = Vertex.ByCoordinates((v0.X() + v2.X()) / 2, (v0.Y() + v2.Y()) / 2, (v0.Z() + v2.Z()) / 2)
+            m03 = Vertex.ByCoordinates((v0.X() + v3.X()) / 2, (v0.Y() + v3.Y()) / 2, (v0.Z() + v3.Z()) / 2)
+            m12 = Vertex.ByCoordinates((v1.X() + v2.X()) / 2, (v1.Y() + v2.Y()) / 2, (v1.Z() + v2.Z()) / 2)
+            m13 = Vertex.ByCoordinates((v1.X() + v3.X()) / 2, (v1.Y() + v3.Y()) / 2, (v1.Z() + v3.Z()) / 2)
+            m23 = Vertex.ByCoordinates((v2.X() + v3.X()) / 2, (v2.Y() + v3.Y()) / 2, (v2.Z() + v3.Z()) / 2)
+
+            # Create smaller tetrahedra
+            tetrahedra = [
+                Cell.ByFaces([
+                    Face.ByVertices([v0, m01, m02]),
+                    Face.ByVertices([v0, m01, m03]),
+                    Face.ByVertices([v0, m02, m03]),
+                    Face.ByVertices([m01, m02, m03])
+                ]),
+                Cell.ByFaces([
+                    Face.ByVertices([m01, v1, m12]),
+                    Face.ByVertices([m01, v1, m13]),
+                    Face.ByVertices([m01, m12, m13]),
+                    Face.ByVertices([v1, m12, m13])
+                ]),
+                Cell.ByFaces([
+                    Face.ByVertices([m02, m12, v2]),
+                    Face.ByVertices([m02, m12, m23]),
+                    Face.ByVertices([m02, v2, m23]),
+                    Face.ByVertices([m12, v2, m23])
+                ]),
+                Cell.ByFaces([
+                    Face.ByVertices([m03, m13, m23]),
+                    Face.ByVertices([m03, v3, m13]),
+                    Face.ByVertices([m03, v3, m23]),
+                    Face.ByVertices([m13, v3, m23])
+                ])
+            ]
+
+            # Recursively subdivide the smaller tetrahedra
+            result = []
+            for t in tetrahedra:
+                result.extend(subdivide_tetrahedron(t, depth - 1))
+            return result
+
+        if not Topology.IsInstance(origin, "vertex"):
+            origin = Vertex.Origin()
+        
+        # Define the four vertices of the tetrahedron
+        v0 = Vertex.ByCoordinates(0, 0, 0)
+        v1 = Vertex.ByCoordinates(length, 0, 0)
+        v2 = Vertex.ByCoordinates(length/2, sqrt(3)/2*length, 0)
+        v3 = Vertex.ByCoordinates(length/2, sqrt(3)/2*length/3, sqrt(2/3)*length)
+
+        # Create the initial tetrahedron
+        tetrahedron = Cell.ByFaces([
+            Face.ByVertices([v0, v1, v2]),
+            Face.ByVertices([v0, v1, v3]),
+            Face.ByVertices([v1, v2, v3]),
+            Face.ByVertices([v2, v0, v3]),
+        ])
+
+        bbox = Topology.BoundingBox(tetrahedron)
+        d = Topology.Dictionary(bbox)
+        bb_width = Dictionary.ValueAtKey(d, "width")
+        bb_length = Dictionary.ValueAtKey(d, "length")
+        bb_height = Dictionary.ValueAtKey(d, "height")
+        
+        centroid = Topology.Centroid(tetrahedron)
+        c_x, c_y, c_z = Vertex.Coordinates(centroid, mantissa=mantissa)
+
+        if placement.lower() == "center":
+            tetrahedron = Topology.Translate(tetrahedron, -c_x, -c_y, -c_z)
         elif placement.lower() == "bottom":
-            tetrahedron = Topology.Translate(tetrahedron, 0, 0, radius)
-        tetrahedron = Topology.Place(tetrahedron, originA=Vertex.Origin(), originB=origin)
-        tetrahedron = Topology.Orient(tetrahedron, origin=origin, dirA=[0, 0, 1], dirB=direction, tolerance=tolerance)
-        return tetrahedron
+            tetrahedron = Topology.Translate(tetrahedron,-c_x, -c_y, 0)
+        elif placement.lower() == "upperleft":
+            tetrahedron = Topology.Translate(tetrahedron, 0, 0, -bb_height)
+        elif placement.lower() == "upperright":
+            tetrahedron = Topology.Translate(tetrahedron, -bb_width, -bb_length, -bb_height)
+        elif placement.lower() == "bottomright":
+            tetrahedron = Topology.Translate(tetrahedron, -bb_width, -bb_length, 0)
+        elif placement.lower() == "top":
+            tetrahedron = Topology.Translate(tetrahedron,-c_x, -c_y, -bb_height)
+        
+        tetrahedron = Topology.Place(tetrahedron, Vertex.Origin(), origin)
+        if not direction == [0,0,1]:
+            tetrahedron = Topology.Orient(tetrahedron, origin=origin, dirA=[0,0,1], dirB=direction)
+
+        depth = max(depth, 0)
+        if depth == 0:
+            return tetrahedron
+        else:
+            # Recursively subdivide the tetrahedron
+            subdivided_tetrahedra = subdivide_tetrahedron(tetrahedron, depth)
+            # Create a cell complex from the subdivided tetrahedra
+            return CellComplex.ExternalBoundary(CellComplex.ByCells([tetrahedron]+subdivided_tetrahedra))
     
     @staticmethod
     def Torus(origin= None, majorRadius: float = 0.5, minorRadius: float = 0.125, uSides: int = 16, vSides: int = 8, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001):

topologicpy/CellComplex.py

@@ -1012,6 +1012,151 @@ class CellComplex():
         shells = Topology.Shells(cellComplex)
         return shells
 
+    @staticmethod
+    def Tetrahedron(origin = None, length: float = 1, depth: int = 1, direction=[0,0,1], placement="center", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Creates a recursive tetrahedron cellComplex with internal cells.
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex , optional
+            The origin location of the tetrahedron. The default is None which results in the tetrahedron being placed at (0, 0, 0).
+        length : float , optional
+            The length of the edge of the tetrahedron. The default is 1.
+        depth : int , optional
+            The desired maximum number of recrusive subdivision levels.
+        direction : list , optional
+            The vector representing the up direction of the tetrahedron. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the tetrahedron. This can be "bottom", "center", or "lowerleft". It is case insensitive. The default is "center".
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        
+        Returns
+        -------
+        topologic_core.CellComplex
+            The created tetrahedron.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Face import Face
+        from topologicpy.Cell import Cell
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+
+        from math import sqrt
+
+        def subdivide_tetrahedron(tetrahedron, depth):
+            """
+            Recursively subdivides a tetrahedron into smaller tetrahedra.
+
+            Parameters:
+                tetrahedron (Cell): The tetrahedron to subdivide.
+                depth (int): Recursion depth for the subdivision.
+
+            Returns:
+                list: List of smaller tetrahedral cells.
+            """
+            if depth == 0:
+                return [tetrahedron]
+
+            # Extract the vertices of the tetrahedron
+            vertices = Topology.Vertices(tetrahedron)
+            v0, v1, v2, v3 = vertices
+
+            # Calculate midpoints of the edges
+            m01 = Vertex.ByCoordinates((v0.X() + v1.X()) / 2, (v0.Y() + v1.Y()) / 2, (v0.Z() + v1.Z()) / 2)
+            m02 = Vertex.ByCoordinates((v0.X() + v2.X()) / 2, (v0.Y() + v2.Y()) / 2, (v0.Z() + v2.Z()) / 2)
+            m03 = Vertex.ByCoordinates((v0.X() + v3.X()) / 2, (v0.Y() + v3.Y()) / 2, (v0.Z() + v3.Z()) / 2)
+            m12 = Vertex.ByCoordinates((v1.X() + v2.X()) / 2, (v1.Y() + v2.Y()) / 2, (v1.Z() + v2.Z()) / 2)
+            m13 = Vertex.ByCoordinates((v1.X() + v3.X()) / 2, (v1.Y() + v3.Y()) / 2, (v1.Z() + v3.Z()) / 2)
+            m23 = Vertex.ByCoordinates((v2.X() + v3.X()) / 2, (v2.Y() + v3.Y()) / 2, (v2.Z() + v3.Z()) / 2)
+
+            # Create smaller tetrahedra
+            tetrahedra = [
+                Cell.ByFaces([
+                    Face.ByVertices([v0, m01, m02]),
+                    Face.ByVertices([v0, m01, m03]),
+                    Face.ByVertices([v0, m02, m03]),
+                    Face.ByVertices([m01, m02, m03])
+                ]),
+                Cell.ByFaces([
+                    Face.ByVertices([m01, v1, m12]),
+                    Face.ByVertices([m01, v1, m13]),
+                    Face.ByVertices([m01, m12, m13]),
+                    Face.ByVertices([v1, m12, m13])
+                ]),
+                Cell.ByFaces([
+                    Face.ByVertices([m02, m12, v2]),
+                    Face.ByVertices([m02, m12, m23]),
+                    Face.ByVertices([m02, v2, m23]),
+                    Face.ByVertices([m12, v2, m23])
+                ]),
+                Cell.ByFaces([
+                    Face.ByVertices([m03, m13, m23]),
+                    Face.ByVertices([m03, v3, m13]),
+                    Face.ByVertices([m03, v3, m23]),
+                    Face.ByVertices([m13, v3, m23])
+                ])
+            ]
+
+            # Recursively subdivide the smaller tetrahedra
+            result = []
+            for t in tetrahedra:
+                result.extend(subdivide_tetrahedron(t, depth - 1))
+            return result
+
+        if not Topology.IsInstance(origin, "vertex"):
+            origin = Vertex.Origin()
+        
+        # Define the four vertices of the tetrahedron
+        v0 = Vertex.ByCoordinates(0, 0, 0)
+        v1 = Vertex.ByCoordinates(length, 0, 0)
+        v2 = Vertex.ByCoordinates(length/2, sqrt(3)/2*length, 0)
+        v3 = Vertex.ByCoordinates(length/2, sqrt(3)/2*length/3, sqrt(2/3)*length)
+
+        # Create the initial tetrahedron
+        tetrahedron = Cell.ByFaces([
+            Face.ByVertices([v0, v1, v2]),
+            Face.ByVertices([v0, v1, v3]),
+            Face.ByVertices([v1, v2, v3]),
+            Face.ByVertices([v2, v0, v3]),
+        ])
+
+        bbox = Topology.BoundingBox(tetrahedron)
+        d = Topology.Dictionary(bbox)
+        bb_width = Dictionary.ValueAtKey(d, "width")
+        bb_length = Dictionary.ValueAtKey(d, "length")
+        bb_height = Dictionary.ValueAtKey(d, "height")
+        
+        centroid = Topology.Centroid(tetrahedron)
+        c_x, c_y, c_z = Vertex.Coordinates(centroid, mantissa=mantissa)
+
+        if placement.lower() == "center":
+            tetrahedron = Topology.Translate(tetrahedron, -c_x, -c_y, -c_z)
+        elif placement.lower() == "bottom":
+            tetrahedron = Topology.Translate(tetrahedron,-c_x, -c_y, 0)
+        elif placement.lower() == "upperleft":
+            tetrahedron = Topology.Translate(tetrahedron, 0, 0, -bb_height)
+        elif placement.lower() == "upperright":
+            tetrahedron = Topology.Translate(tetrahedron, -bb_width, -bb_length, -bb_height)
+        elif placement.lower() == "bottomright":
+            tetrahedron = Topology.Translate(tetrahedron, -bb_width, -bb_length, 0)
+        elif placement.lower() == "top":
+            tetrahedron = Topology.Translate(tetrahedron,-c_x, -c_y, -bb_height)
+        
+        tetrahedron = Topology.Place(tetrahedron, Vertex.Origin(), origin)
+        if not direction == [0,0,1]:
+            tetrahedron = Topology.Orient(tetrahedron, origin=origin, dirA=[0,0,1], dirB=direction)
+
+        depth = max(depth, 1)
+        # Recursively subdivide the tetrahedron
+        subdivided_tetrahedra = subdivide_tetrahedron(tetrahedron, depth)
+        # Create a cell complex from the subdivided tetrahedra
+        return CellComplex.ByCells([tetrahedron]+subdivided_tetrahedra)
+    
     @staticmethod
     def Torus(origin= None, majorRadius: float = 0.5, minorRadius: float = 0.125, uSides: int = 16, vSides: int = 8, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001):
         """

topologicpy/Graph.py

@@ -1358,7 +1358,7 @@ class Graph:
         return bot_graph.serialize(format=format)
 
     @staticmethod
-    def BetweennessCentrality(graph, method: str = "vertex", weightKey="length", normalize: bool = False, nx: bool = False, key: str = "betweenness_centrality", colorKey="bc_color", colorScale="viridis", mantissa: int = 6, tolerance: float = 0.001, silent: bool = False):
+    def BetweennessCentrality(graph, method: str = "vertex", weightKey="length", normalize: bool = False, nxCompatible: bool = False, key: str = "betweenness_centrality", colorKey="bc_color", colorScale="viridis", mantissa: int = 6, tolerance: float = 0.001, silent: bool = False):
         """
             Returns the betweenness centrality of the input graph. The order of the returned list is the same as the order of vertices/edges. See https://en.wikipedia.org/wiki/Betweenness_centrality.
 
@@ -1374,7 +1374,7 @@ class Graph:
             This is used in weighted graphs. if weightKey is set to "Length" or "Distance", the length of the edge will be used as its weight.
         normalize : bool , optional
             If set to True, the values are normalized to be in the range 0 to 1. Otherwise they are not. The default is False.
-        nx : bool , optional
+        nxCompatible : bool , optional
             If set to True, and normalize input parameter is also set to True, the values are set to be identical to NetworkX values. Otherwise, they are normalized between 0 and 1. The default is False.
         key : str , optional
             The desired dictionary key under which to store the betweenness centrality score. The default is "betweenness_centrality".
@@ -1423,12 +1423,12 @@ class Graph:
         if "vert" in method.lower():
             elements = Graph.Vertices(graph)
             elements_dict = nx.betweenness_centrality(nx_graph, normalized=normalize, weight=weightKey)
-            values = list(elements_dict.values())
+            values = [round(value, mantissa) for value in list(elements_dict.values())]
         else:
             elements = Graph.Edges(graph)
             elements_dict = nx.edge_betweenness_centrality(nx_graph, normalized=normalize, weight=weightKey)
             values = [round(value, mantissa) for value in list(elements_dict.values())]
-        if nx == False:
+        if nxCompatible == False:
             if mantissa > 0: # We cannot have values in the range 0 to 1 with a mantissa < 1
                 values = [round(v, mantissa) for v in Helper.Normalize(values)]
             else:
@@ -4686,7 +4686,7 @@ class Graph:
         return graph
     
     @staticmethod
-    def ClosenessCentrality(graph, weightKey="length", normalize: bool = False, nx: bool = True, key: str = "closeness_centrality", colorKey="cc_color", colorScale="viridis", mantissa: int = 6, tolerance: float = 0.001, silent: bool = False):
+    def ClosenessCentrality(graph, weightKey="length", normalize: bool = False, nxCompatible: bool = True, key: str = "closeness_centrality", colorKey="cc_color", colorScale="viridis", mantissa: int = 6, tolerance: float = 0.001, silent: bool = False):
         """
             Returns the closeness centrality of the input graph. The order of the returned list is the same as the order of vertices/edges. See https://en.wikipedia.org/wiki/Betweenness_centrality.
 
@@ -4700,7 +4700,7 @@ class Graph:
             This is used in weighted graphs. if weightKey is set to "Length" or "Distance", the length of the edge will be used as its weight.
         normalize : bool , optional
             If set to True, the values are normalized to be in the range 0 to 1. Otherwise they are not. The default is False.
-        nx : bool , optional
+        nxCompatible : bool , optional
             If set to True, use networkX to scale by the fraction of nodes reachable. This gives the Wasserman and Faust improved formula.
             For single component graphs it is the same as the original formula.
         key : str , optional
@@ -4753,7 +4753,7 @@ class Graph:
                 weightKey = "length"
         nx_graph = Graph.NetworkXGraph(graph)
         elements = Graph.Vertices(graph)
-        elements_dict = nx.closeness_centrality(nx_graph, distance=weightKey, wf_improved=nx)
+        elements_dict = nx.closeness_centrality(nx_graph, distance=weightKey, wf_improved=nxCompatible)
         values = [round(v, mantissa) for v in list(elements_dict.values())]
         if normalize == True:
             if mantissa > 0: # We cannot round numbers from 0 to 1 with a mantissa = 0.

topologicpy/Honeybee.py

@@ -300,33 +300,27 @@ class Honeybee:
         sensorGrids = []
         for spaceNumber, tpCell in enumerate(tpCells):
             tpDictionary = Topology.Dictionary(tpCell)
-            tpCellName = None
-            tpCellStory = None
+            tpCellName = "Untitled Space"
+            tpCellStory = fl[0]
             tpCellProgramIdentifier = None
             tpCellConstructionSetIdentifier = None
             tpCellConditioned = True
             if tpDictionary:
                 keyName = getKeyName(tpDictionary, 'Story')
-                try:
-                    tpCellStory = Dictionary.ValueAtKey(tpDictionary, keyName)
-                    if tpCellStory:
-                        tpCellStory = tpCellStory.replace(" ","_")
-                except:
-                    tpCellStory = fl[spaceNumber]
+                tpCellStory = Dictionary.ValueAtKey(tpDictionary, keyName, silent=True) or fl[spaceNumber]
+                if tpCellStory:
+                    tpCellStory = tpCellStory.replace(" ","_")
+                else:
+                    tpCellStory = "Untitled_Floor"
                 if roomNameKey:
                     keyName = getKeyName(tpDictionary, roomNameKey)
                 else:
                     keyName = getKeyName(tpDictionary, 'Name')
-                try:
-                    tpCellName = Dictionary.ValueAtKey(tpDictionary,keyName)
-                    if tpCellName:
-                        tpCellName = createUniqueName(tpCellName.replace(" ","_"), spaceNames, 1)
-                except:
-                    tpCellName = tpCellStory+"_SPACE_"+(str(spaceNumber+1))
+                tpCellName = Dictionary.ValueAtKey(tpDictionary,keyName, silent=True) or createUniqueName(tpCellStory+"_SPACE_"+(str(spaceNumber+1)), spaceNames, 1)
                 if roomTypeKey:
                     keyName = getKeyName(tpDictionary, roomTypeKey)
                 try:
-                    tpCellProgramIdentifier = Dictionary.ValueAtKey(tpDictionary, keyName)
+                    tpCellProgramIdentifier = Dictionary.ValueAtKey(tpDictionary, keyName, silent=True)
                     if tpCellProgramIdentifier:
                         program = prog_type_lib.program_type_by_identifier(tpCellProgramIdentifier)
                     elif defaultProgramIdentifier:
@@ -335,7 +329,7 @@ class Honeybee:
                     program = prog_type_lib.office_program #Default Office Program as a last resort
                 keyName = getKeyName(tpDictionary, 'construction_set')
                 try:
-                    tpCellConstructionSetIdentifier = Dictionary.ValueAtKey(tpDictionary, keyName)
+                    tpCellConstructionSetIdentifier = Dictionary.ValueAtKey(tpDictionary, keyName, silent=True)
                     if tpCellConstructionSetIdentifier:
                         constr_set = constr_set_lib.construction_set_by_identifier(tpCellConstructionSetIdentifier)
                     elif defaultConstructionSetIdentifier:
@@ -344,7 +338,7 @@ class Honeybee:
                     constr_set = constr_set_lib.construction_set_by_identifier("Default Generic Construction Set")
             else:
                 tpCellStory = fl[spaceNumber]
-                tpCellName = tpCellStory+"_SPACE_"+(str(spaceNumber+1))
+                tpCellName = str(tpCellStory)+"_SPACE_"+(str(spaceNumber+1))
                 program = prog_type_lib.office_program
                 constr_set = constr_set_lib.construction_set_by_identifier("Default Generic Construction Set")
             spaceNames.append(tpCellName)
@@ -366,7 +360,7 @@ class Honeybee:
                             tpFaceApertureDictionary = Topology.Dictionary(apertureTopology)
                             if tpFaceApertureDictionary:
                                 apertureKeyName = getKeyName(tpFaceApertureDictionary, apertureTypeKey)
-                                tpFaceApertureType = Dictionary.ValueAtKey(tpFaceApertureDictionary,apertureKeyName)
+                                tpFaceApertureType = Dictionary.ValueAtKey(tpFaceApertureDictionary,apertureKeyName, silent=True)
                             hbFaceAperturePoints = []
                             tpFaceApertureVertices = []
                             tpFaceApertureVertices = Topology.Vertices(Face.ExternalBoundary(apertureTopology))
@@ -383,7 +377,7 @@ class Honeybee:
                     else:
                         tpFaceDictionary = Topology.Dictionary(tpCellFace)
                         if (abs(tpCellFaceNormal[2]) < 1e-6) and tpFaceDictionary: #It is a mostly vertical wall and has a dictionary
-                            apertureRatio = Dictionary.ValueAtKey(tpFaceDictionary,'apertureRatio')
+                            apertureRatio = Dictionary.ValueAtKey(tpFaceDictionary,'apertureRatio', silent=True)
                             if apertureRatio:
                                 hbRoomFace.apertures_by_ratio(apertureRatio, tolerance=0.01)
                     fType = honeybee.facetype.get_type_from_normal(Vector3D(tpCellFaceNormal[0],tpCellFaceNormal[1],tpCellFaceNormal[2]), roof_angle=30, floor_angle=150)

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.12'
+__version__ = '0.8.14'

{topologicpy-0.8.12.dist-info → topologicpy-0.8.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: topologicpy
-Version: 0.8.12
+Version: 0.8.14
 Summary: An AI-Powered Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 License: AGPL v3 License

{topologicpy-0.8.12.dist-info → topologicpy-0.8.14.dist-info}/RECORD

@@ -1,8 +1,8 @@
 topologicpy/ANN.py,sha256=m_WxD1lgQqDhUpaM20Lia6TmJACDYaAE96wigsi-99U,47932
 topologicpy/Aperture.py,sha256=p9pUzTQSBWoUaDiug1V1R1hnEIEwYSXFg2t7iRAmNRY,2723
 topologicpy/BVH.py,sha256=1q2lR5eDs7Wnwv7M-Kr7Cj3GG_iy7d1ddaZqWGHdX-w,12932
-topologicpy/Cell.py,sha256=Wwr2RsNEagfdt4Uz0GYosRTgNQj0pc5NOlzEWbL7cjQ,114343
-topologicpy/CellComplex.py,sha256=23bO0RYFIg6MOyt3PMFayaK523Alt8aHhc6UyJO02X0,51610
+topologicpy/Cell.py,sha256=DYVXGfzioMBsQOkrP-BhJ5iHExKhTGAxOhMlmWeG4vw,118262
+topologicpy/CellComplex.py,sha256=udDzbMub3d2QYn1XGMzt3F9Su2VXuAGvn0eoTtOIn3g,58207
 topologicpy/Cluster.py,sha256=o5jdMRpcGfSGGiXQdFg-e9XcnBF5AqTj3xb1nSpwJWE,58606
 topologicpy/Color.py,sha256=q9xsGmxFMz7sQKmygwSVS12GaTRB-OT0-_i6t3-cthE,20307
 topologicpy/Context.py,sha256=ppApYKngZZCQBFWaxIMi2z2dokY23c935IDCBosxDAE,3055
@@ -11,10 +11,10 @@ topologicpy/Dictionary.py,sha256=t0O7Du-iPq46FyKqZfcjHfsUK1E8GS_e67R2V5cpkbw,331
 topologicpy/Edge.py,sha256=yxkCVDYBflJNEYxnjMmlyvbkpg8TNy7y5bSH3yQ4jzs,71418
 topologicpy/EnergyModel.py,sha256=UoQ9Jm-hYsN383CbcLKw-y6BKitRHj0uyh84yQ-8ACg,53856
 topologicpy/Face.py,sha256=tn3PI-t9rXikgI1QMclw0PFwQ5vvyLi-wJKqZZZ9xmw,182755
-topologicpy/Graph.py,sha256=4zO0ntmRFz4k1WtsLmsbzjlor1tuQGLBIkpFk2Y_4hI,498848
+topologicpy/Graph.py,sha256=FBmiMObzztPwZFJ2T846Ivz0Y1kpzMF0sF-PDUMPk4o,498946
 topologicpy/Grid.py,sha256=2s9cSlWldivn1i9EUz4OOokJyANveqmRe_vR93CAndI,18245
 topologicpy/Helper.py,sha256=4H5KPiv_eiEs489UOOyGLe9RaeoZIfmMh3mk_YCHmXg,29100
-topologicpy/Honeybee.py,sha256=Y_El6M8x3ixvvIe_VcRiwj_4C89ZZg5_WlT7adbCkpw,21849
+topologicpy/Honeybee.py,sha256=uDVtDbloydNoaBFcSNukKL_2PLyD6XKkCp1VHz1jtaU,21751
 topologicpy/Matrix.py,sha256=mqcCk14kM9OOwJPwd9ce-8SFM0IxS3jYb2XpWhVjUAc,19503
 topologicpy/Neo4j.py,sha256=BKOF29fRgXmdpMGkrNzuYbyqgCJ6ElPPMYlfTxXiVbc,22392
 topologicpy/Plotly.py,sha256=RU_VioIRLGIYzwyKI9OQHOx9OxxGppdpagysgTbdxIE,115942
@@ -28,9 +28,9 @@ topologicpy/Vector.py,sha256=GkGt-aJ591IJ2IPffMAudvITLDPi2qZibZc4UAav6m8,42407
 topologicpy/Vertex.py,sha256=xr8KSgKnx-hgVp-eIvMPAKRv04R-wk-_4zc57xVyEqE,80793
 topologicpy/Wire.py,sha256=x7tOeR1o5qi5cXp_d9JrQrSXfYztCWiBC1OnVl6Yp7A,228463
 topologicpy/__init__.py,sha256=vlPCanUbxe5NifC4pHcnhSzkmmYcs_UrZrTlVMsxcFs,928
-topologicpy/version.py,sha256=VV54c1MEFjYlfKiA8ImJRkIYgUTfdMJOJs5zzf-BKgE,23
-topologicpy-0.8.12.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.12.dist-info/METADATA,sha256=owpJTXYjSfnJDFWPqrGOm1DoEVeWTghesziE4T-nt2I,10513
-topologicpy-0.8.12.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-topologicpy-0.8.12.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.12.dist-info/RECORD,,
+topologicpy/version.py,sha256=Lw9k1hHakMjGPEzEp8wU2hEIGzA0_SHXmAYeLmbM_Kg,23
+topologicpy-0.8.14.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.14.dist-info/METADATA,sha256=HVOo7iDJt80dFu4DEf_0H0du_Zq8rCW2WFLikjwb7HU,10513
+topologicpy-0.8.14.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+topologicpy-0.8.14.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.14.dist-info/RECORD,,