compas-cem 0.7.0__py2.py3-none-any.whl → 0.8.2__py2.py3-none-any.whl

compas_cem/__init__.py

@@ -27,7 +27,7 @@ __author__ = ["Rafael Pastrana"]
 __copyright__ = "Copyright 2020 - Princeton University"
 __license__ = "MIT License"
 __email__ = "arpj@princeton.edu"
-__version__ = "0.7.0"
+__version__ = "0.8.2"
 
 
 # Directories

compas_cem/diagrams/diagram.py

@@ -255,6 +255,22 @@ class Diagram(Data, NodeMixins, EdgeMixins, Network):
         """
         return self.edge_attribute(key=edge, name="length")
 
+    def edge_plane(self, edge):
+        """
+        Gets the projection plane at an edge.
+
+        Parameters
+        ----------
+        edge : ``tuple``
+            The u, v edge key.
+
+        Return
+        ------
+        plane : ``tuple``
+            The projection plane of the edge.
+        """
+        return self.edge_attribute(key=edge, name="plane")
+
 # ==============================================================================
 # Magic methods
 # ==============================================================================

compas_cem/diagrams/topology/topology.py

@@ -737,7 +737,8 @@ class TopologyDiagram(Diagram, MeshMixins):
         flag : ``bool``
             ``True``if the edge is in an auxiliary trail. ``False`` otherwise.
         """
-        if edge in set(self.auxiliary_trails()):
+        aux_trails = set([tuple(edge) for edge in self.auxiliary_trails()])
+        if edge in set(aux_trails):
             return True
         return False
 
@@ -910,7 +911,7 @@ class TopologyDiagram(Diagram, MeshMixins):
 
     def trail_sequences(self, key):
         """
-        Create a mapping between the sequences in the diagram and the nodes in the trail.
+        Create a mapping between topological sequences and the nodes in a trail.
 
         Parameters
         ----------
@@ -930,7 +931,9 @@ class TopologyDiagram(Diagram, MeshMixins):
 
     def trails_sequences(self):
         """
-        Creates a mapping between the nodes in all the trails and the available sequences.
+        Creates a mapping of mappings between the nodes of the trails and the sequences.
+
+        The mapping has the form ``{trail_key: {sequence: node}}``.
 
         Returns
         -------

compas_cem/equilibrium/__init__.py

@@ -29,4 +29,5 @@ import compas
 if not compas.IPY:
     from .force_numpy import *  # noqa F403
 
+
 __all__ = [name for name in dir() if not name.startswith('_')]

compas_cem/equilibrium/force.py

@@ -69,6 +69,7 @@ def equilibrium_state(topology, kmax=None, tmax=100, eta=1e-6, verbose=False, ca
     # create data containers that describe equilibrium state
     reaction_forces = {}
     trail_forces = {}
+    trail_directions = {}
     residual_vectors = {node: topology.reaction_force(node) for node in topology.nodes()}
     node_xyz = {node: topology.node_coordinates(node) for node in topology.nodes()}
 
@@ -84,7 +85,7 @@ def equilibrium_state(topology, kmax=None, tmax=100, eta=1e-6, verbose=False, ca
         # store last positions for residual
         last_xyz = {k: v for k, v in node_xyz.items()}
 
-        for k in range(klast + 1):  # sequences
+        for k in range(topology.number_of_sequences()):  # sequences
 
             for key, trail in topology.trails(keys=True):
 
@@ -144,12 +145,16 @@ def equilibrium_state(topology, kmax=None, tmax=100, eta=1e-6, verbose=False, ca
                         length = plength
 
                 # store next node position
-                next_pos = add_vectors(pos, scale_vector(normalize_vector(rvec), length))
+                nrvec = normalize_vector(rvec)
+                next_pos = add_vectors(pos, scale_vector(nrvec, length))
                 node_xyz[next_node] = next_pos
 
                 # store trail force
                 trail_forces[edge] = copysign(length_vector(rvec), length)
 
+                # store trail direction
+                trail_directions[edge] = nrvec
+
                 # store residual vector
                 residual_vectors[next_node] = rvec
 
@@ -185,11 +190,12 @@ def equilibrium_state(topology, kmax=None, tmax=100, eta=1e-6, verbose=False, ca
     eq_state["node_xyz"] = node_xyz
     eq_state["trail_forces"] = trail_forces
     eq_state["reaction_forces"] = reaction_forces
+    eq_state["trail_directions"] = trail_directions
 
     return eq_state
 
 
-def form_update(form, node_xyz, trail_forces, reaction_forces):
+def form_update(form, node_xyz, trail_forces, reaction_forces, **kwargs):
     """
     Update the node and edge attributes of a form after equilibrating it.
     """

compas_cem/equilibrium/force_numpy.py

@@ -57,7 +57,7 @@ def equilibrium_state_numpy(topology, tmax=100, eta=1e-6, verbose=False, callbac
 
     # output, mutable
     edge_forces = {e: np.array(topology.edge_force(e)) for e in topology.edges()}
-    edge_lengths = {e: np.array(topology.edge_attribute(e, "length")) for e in topology.edges()}
+    edge_lengths = {e: np.array(topology.edge_length_2(e)) for e in topology.edges()}
 
     # input, immutable
     # numpy
@@ -70,7 +70,7 @@ def equilibrium_state_numpy(topology, tmax=100, eta=1e-6, verbose=False, callbac
     # edge planes
     edge_planes = {}
     for edge in topology.trail_edges():
-        plane = topology.edge_attribute(edge, "plane")
+        plane = topology.edge_plane(edge)
         if not plane:
             continue
         plane = [np.array(vector) for vector in plane]
@@ -82,6 +82,7 @@ def equilibrium_state_numpy(topology, tmax=100, eta=1e-6, verbose=False, callbac
     # output
     reaction_forces = {}
     trail_forces = {}
+    trail_directions = {}
 
     for t in range(tmax):  # max iterations
 
@@ -152,11 +153,15 @@ def equilibrium_state_numpy(topology, tmax=100, eta=1e-6, verbose=False, callbac
                 # compute trail force
                 trail_force = length_vector_numpy(rvec)  # always positive
 
+                # compute trail direction by normalizing residual vector
                 # NOTE: to avoid NaNs, do not normalize residual vector if it is zero length
                 nrvec = rvec / trail_force
                 if np.isnan(length_vector_numpy(nrvec)):
                     nrvec = rvec
 
+                # store trail direction
+                trail_directions[edge] = nrvec
+
                 # store next node position
                 next_pos = pos + length * nrvec
                 node_xyz[next_node] = next_pos
@@ -203,13 +208,14 @@ def equilibrium_state_numpy(topology, tmax=100, eta=1e-6, verbose=False, callbac
     eq_state = {}
     eq_state["node_xyz"] = node_xyz
     eq_state["trail_forces"] = trail_forces
+    eq_state["trail_directions"] = trail_directions
     eq_state["reaction_forces"] = reaction_forces
 
     # return node_xyz, trail_forces, reaction_forces
     return eq_state
 
 
-def form_update(form, node_xyz, trail_forces, reaction_forces):
+def form_update(form, node_xyz, trail_forces, reaction_forces, **kwargs):
     """
     Update the node and edge attributes of a form after equilibrating it.
     """

compas_cem/ghpython/components/CompasCem_ConstraintEdgeDirection/code.py

@@ -0,0 +1,17 @@
+"""
+Align the direction of a trail or a deviation edge with a target vector.
+"""
+
+from ghpythonlib.componentbase import executingcomponent as component
+
+from compas_cem.optimization import EdgeDirectionConstraint
+from compas_rhino.geometry import RhinoVector
+
+
+class EdgeDirectionConstraintComponent(component):
+    def RunScript(self, edge_key, vector, weight):
+        weight = weight or 1.0
+        if not edge_key or not vector:
+            return
+        vector = RhinoVector.from_geometry(vector).to_compas()
+        return EdgeDirectionConstraint(edge_key, vector, weight)

compas_cem/ghpython/components/CompasCem_ConstraintEdgeDirection/metadata.json

@@ -0,0 +1,35 @@
+{
+    "name": "Edge Direction Constraint",
+    "nickname": "EdgeDirectionConstraint",
+    "category": "COMPAS CEM",
+    "subcategory": "06_Optimization",
+    "description": "Align the direction of a trail or a deviation edge with a target vector.",
+    "exposure": 4,
+
+    "ghpython": {
+        "isAdvancedMode": true,
+        "inputParameters": [
+            {
+                "name": "edge_key",
+                "description": "The key of a COMPAS CEM trail or deviation edge."
+            },
+            {
+                "name": "vector",
+                "description": "The target vector.",
+                "typeHintID": "vector"
+            },
+            {
+                "name": "weight",
+                "description": "The weight of the constraint in the optimization problem. Defaults to one.",
+                "typeHintID": "float"
+            }
+        ],
+        "outputParameters": [
+            {
+                "name": "constraint",
+                "description": "A COMPAS CEM edge direction constraint.",
+                "optional": false
+            }
+        ]
+    }
+}

compas_cem/ghpython/components/CompasCem_ConstraintNodePolyline/code.py

@@ -0,0 +1,16 @@
+"""
+Pull the position of a node to a target polyline.
+"""
+from ghpythonlib.componentbase import executingcomponent as component
+
+from compas_cem.optimization import PolylineConstraint
+from compas_rhino.geometry import RhinoPolyline
+
+
+class PolylineConstraintComponent(component):
+    def RunScript(self, node_key, polyline, weight):
+        weight = weight or 1.0
+        if node_key is None or not polyline:
+            return
+        polyline = RhinoPolyline.from_geometry(polyline).to_compas()
+        return PolylineConstraint(node_key, polyline, weight)

compas_cem/ghpython/components/CompasCem_ConstraintNodePolyline/metadata.json

@@ -0,0 +1,36 @@
+{
+    "name": "Polyline Constraint",
+    "nickname": "PolylineConstraint",
+    "category": "COMPAS CEM",
+    "subcategory": "06_Optimization",
+    "description": "Pull the position of a node to a target polyline.",
+    "exposure": 4,
+
+    "ghpython": {
+        "isAdvancedMode": true,
+        "inputParameters": [
+            {
+                "name": "node_key",
+                "description": "The key of a COMPAS CEM node.",
+                "typeHintID": "int"
+            },
+            {
+                "name": "polyline",
+                "description": "The target polyline.",
+                "typeHintID": "polyline"
+            },
+            {
+                "name": "weight",
+                "description": "The weight of the constraint in the optimization problem. Defaults to one.",
+                "typeHintID": "float"
+            }
+        ],
+        "outputParameters": [
+            {
+                "name": "constraint",
+                "description": "A COMPAS CEM node polyline constraint.",
+                "optional": false
+            }
+        ]
+    }
+}

compas_cem/optimization/constraints/__init__.py

@@ -34,6 +34,8 @@ from .plane import *  # noqa F403
 from .line import *  # noqa F403
 from .force import *  # noqa F403
 from .length import *  # noqa F403
+from .direction import *  # noqa F403
+from .polyline import *  # noqa F403
 
 # import compas
 # if not compas.IPY:

compas_cem/optimization/constraints/direction.py

@@ -0,0 +1,191 @@
+from compas.geometry import dot_vectors
+from compas.geometry import normalize_vector
+from compas.geometry import subtract_vectors
+from compas.geometry import length_vector_sqrd
+from compas.geometry import scale_vector
+
+from compas_cem.optimization.constraints import VectorConstraint
+
+
+__all__ = ["EdgeDirectionConstraint"]
+
+
+class EdgeDirectionConstraint(VectorConstraint):
+    """
+    Align the direction of a trail or a deviation edge with a target vector.
+
+    Note that the ordering of the nodes of the edge to constrain matters.
+    The reference direction of the edge is a vector pointing from its starting node (u),
+    towards its end node (v).
+    """
+    def __init__(self, edge=None, vector=None, weight=1.0):
+        super(EdgeDirectionConstraint, self).__init__(edge, vector, weight)
+
+    def target(self, reference):
+        """
+        The target, unit-length vector.
+        """
+        target = normalize_vector(self._target)
+        return self._aligned_vector(target, reference)
+
+    def reference(self, data):
+        """
+        The unitized edge direction.
+        """
+        vector = self._vector_two_points(self.key(), data)
+        return self._unitized_vector(vector)
+
+    @staticmethod
+    def _vector_two_points(edge, data):
+        """
+        Create a vector from the XYZ coordinates of two nodes.
+        """
+        u, v = edge
+        return subtract_vectors(data["node_xyz"][v], data["node_xyz"][u])
+
+    @staticmethod
+    def _unitized_vector(vector):
+        """
+        Scale a copy of a vector such that its length is equal to one.
+        """
+        return scale_vector(vector, 1.0 / (length_vector_sqrd(vector) ** 0.5))
+
+    @staticmethod
+    def _aligned_vector(vector, vector_ref):
+        """
+        Align a vector to another such that their dot product is non-negative.
+        """
+        if dot_vectors(vector, vector_ref) < 0.0:
+            return scale_vector(vector, -1.0)
+        return vector
+
+
+if __name__ == "__main__":
+
+    from math import fabs
+
+    from compas.geometry import Translation
+
+    from compas_cem.diagrams import TopologyDiagram
+
+    from compas_cem.elements import Node
+    from compas_cem.elements import TrailEdge
+    from compas_cem.elements import DeviationEdge
+
+    from compas_cem.loads import NodeLoad
+    from compas_cem.supports import NodeSupport
+
+    from compas_cem.equilibrium import static_equilibrium
+
+    from compas_cem.optimization import Optimizer
+    from compas_cem.optimization import DeviationEdgeParameter
+
+    from compas_cem.plotters import Plotter
+
+    # ------------------------------------------------------------------------------
+    # Instantiate a topology diagram
+    # ------------------------------------------------------------------------------
+
+    topology = TopologyDiagram()
+
+    # ------------------------------------------------------------------------------
+    # Add nodes
+    # ------------------------------------------------------------------------------
+
+    topology.add_node(Node(0, [0.0, 0.0, 0.0]))
+    topology.add_node(Node(1, [1.0, 0.0, 0.0]))
+    topology.add_node(Node(2, [2.5, 0.0, 0.0]))
+    topology.add_node(Node(3, [3.5, 0.0, 0.0]))
+
+    # ------------------------------------------------------------------------------
+    # Add edges
+    # ------------------------------------------------------------------------------
+
+    topology.add_edge(TrailEdge(1, 0, length=-1.0))
+    topology.add_edge(DeviationEdge(1, 2, force=-1.0))
+    topology.add_edge(TrailEdge(2, 3, length=-1.0))
+
+    # ------------------------------------------------------------------------------
+    # Add supports
+    # ------------------------------------------------------------------------------
+
+    topology.add_support(NodeSupport(0))
+    topology.add_support(NodeSupport(3))
+
+    # ------------------------------------------------------------------------------
+    # Add loads
+    # ------------------------------------------------------------------------------
+
+    topology.add_load(NodeLoad(1, [0.0, -1.0, 0.0]))
+    topology.add_load(NodeLoad(2, [0.0, -1.0, 0.0]))
+
+    # ------------------------------------------------------------------------------
+    # Build trails automatically
+    # ------------------------------------------------------------------------------
+
+    topology.build_trails()
+
+    # ------------------------------------------------------------------------------
+    # Compute a state of static equilibrium
+    # ------------------------------------------------------------------------------
+
+    form = static_equilibrium(topology, eta=1e-6, tmax=100, verbose=True)
+
+    # ------------------------------------------------------------------------------
+    # Initialize optimizer
+    # ------------------------------------------------------------------------------
+
+    opt = Optimizer()
+
+    # ------------------------------------------------------------------------------
+    # Define constraints
+    # ------------------------------------------------------------------------------
+
+    vector = [0.0, -2.0, 0.0]
+    for edge in topology.trail_edges():
+        constraint = EdgeDirectionConstraint(edge, vector)
+        opt.add_constraint(constraint)
+
+    # ------------------------------------------------------------------------------
+    # Define optimization parameters
+    # ------------------------------------------------------------------------------
+
+    for edge in topology.deviation_edges():
+        opt.add_parameter(DeviationEdgeParameter(edge, bound_low=10.0, bound_up=10.0))
+
+    # ------------------------------------------------------------------------------
+    # Optimization
+    # ------------------------------------------------------------------------------
+
+    form_opt = opt.solve(topology=topology,
+                         algorithm="SLSQP",
+                         verbose=True)
+
+    # ------------------------------------------------------------------------------
+    # Test
+    # ------------------------------------------------------------------------------
+
+    for edge in topology.deviation_edges():
+        force = fabs(topology.edge_force(edge))
+        assert force <= 1e-3
+
+    # ------------------------------------------------------------------------------
+    # Plot results
+    # ------------------------------------------------------------------------------
+
+    plotter = Plotter()
+
+    # add topology diagram to scene
+    plotter.add(topology, show_nodetext=True, nodesize=0.2)
+
+    # add shifted form diagram to the scene
+    form = form.transformed(Translation.from_vector([0.0, -1.0, 0.0]))
+    plotter.add(form, nodesize=0.2, show_edgetext=True, edgetext="force")
+
+    # add shifted form diagram to the scene
+    form_opt = form_opt.transformed(Translation.from_vector([0.0, -2.5, 0.0]))
+    plotter.add(form_opt, nodesize=0.2, show_edgetext=True, edgetext="force")
+
+    # show plotter contents
+    plotter.zoom_extents()
+    plotter.show()