Python compute_interface_forces_cvx Examples

Example #1

def calculate(FILE_IN, plot_flag):

    for file in FILE_IN:
        #print("Calculating",file)
        assembly = Assembly.from_json(file)

        # ==============================================================================
        # Identify interfaces
        # ==============================================================================
        assembly_interfaces_numpy(assembly, tmax=0.02)

        # ==============================================================================
        # Equilibrium
        # ==============================================================================
        compute_interface_forces_cvx(assembly, solver='CPLEX', verbose=False)
        #compute_interface_forces_cvx(assembly, solver='ECOS', verbose=True)

        # ==============================================================================
        # Export
        # ==============================================================================
        assembly.to_json(output_path(file))

        if plot_flag:
            R = Rotation.from_axis_and_angle([1.0, 0, 0], -pi / 2)
            assembly.transform(R)

            plotter = AssemblyPlotter(assembly, figsize=(16, 10), tight=True)
            plotter.draw_nodes(radius=0.05)
            plotter.draw_edges()
            plotter.draw_blocks(
                facecolor={
                    key: '#ff0000'
                    for key in assembly.nodes_where({'is_support': True})
                })
            plotter.show()

Example #2

import os
from compas_assembly.datastructures import Assembly
from compas_rbe.equilibrium import compute_interface_forces_cvx

try:
    HERE = os.path.dirname(__file__)
except NameError:
    HERE = os.getcwd()

DATA = os.path.join(HERE, '../../../data')
FILE_I = os.path.join(DATA, 'arch.json')
FILE_O = os.path.join(DATA, 'arch.json')

# ==============================================================================
# Load
# ==============================================================================

assembly = Assembly.from_json(FILE_I)

# ==============================================================================
# Equilibrium
# ==============================================================================

compute_interface_forces_cvx(assembly, solver='CPLEX', verbose=False)

# ==============================================================================
# Export
# ==============================================================================

assembly.to_json(FILE_O)

Example #3

from compas.geometry import Rotation

from compas_assembly.datastructures import Assembly
from compas_assembly.datastructures import assembly_transform
from compas_rbe.equilibrium import compute_interface_forces_cvx

from compas_assembly.plotter import AssemblyPlotter

# load assembly

assembly = Assembly.from_json(compas_assembly.get('stack.json'))

# compute interface forces

compute_interface_forces_cvx(assembly, solver='CVXOPT', verbose=True)

# serialise

assembly.to_json(compas_assembly.get('stack.json'))

# visualise

R = Rotation.from_axis_and_angle([1.0, 0, 0], -pi / 2)
assembly_transform(assembly, R)

plotter = AssemblyPlotter(assembly, tight=True)

plotter.draw_vertices(
    text={key: str(key)
          for key, attr in assembly.vertices(True)})

Example #4

depth = 0.7
thickness = 1
n = 40

assembly = arch_from_rise_and_span(height, span, depth, thickness, n)

# ==============================================================================
# Identify the interfaces
# ==============================================================================

assembly_interfaces_numpy(assembly)

# ==============================================================================
# Compute interface forces
# ==============================================================================

compute_interface_forces_cvx(assembly, solver='CPLEX')

# ==============================================================================
# Visualize
# ==============================================================================

compas_blender.delete_all_objects()

artist = AssemblyArtist(assembly, layer="Assembly")

artist.draw_nodes()
artist.draw_edges()
artist.draw_blocks()
artist.draw_interfaces()

Example #5

sequence = [28, 22, 23, 16, 17, 18, 11, 12, 13, 5, 6, 7, 8, 0, 1, 2, 3, 38]

# create a sub_assembly for the sequence

sub = assembly.subset(sequence)

# check if the sub_assembly is supported

supports = list(sub.vertices_where({'is_support': True}))

if not supports:
    raise Exception('The sub-assembly has no supports.')

# compute the interface forces

compute_interface_forces_cvx(sub, solver='CPLEX', verbose=True)

# update the original assembly

for u, v, attr in assembly.edges(True):
    if sub.has_edge(u, v):
        attr['interface_forces'] = sub.get_edge_attribute((u, v),
                                                          'interface_forces')
    else:
        attr['interface_forces'] = None

# serialise to json

assembly.to_json(compas_assembly.get('wall_equilibrium.json'))