def main():
"""
A sample main program to test our algorithms.
@return: None
"""
t0 = time.time()
# initialize the random generator seed to always use the same set of points
seed(0)
# creates some points
pts = create_points(30)
show = True # to display a frame
save = False # to save into .png files in "figs" directory
scatter_plot(pts, [[]],
title="convex hull : initial set",
show=show,
save=save)
print("Points:", pts)
# compute the hull
hull = Graham(pts, show=show, save=save)
print("Hull:", hull)
scatter_plot(pts, [hull],
title="convex hull : final result",
show=True,
save=save)
t1 = time.time()
print("temps en secondes :")
print(t1 - t0)
def main():
"""
A sample main program to test our algorithms.
@return: None
"""
# initialize the random generator seed to always use the same set of points
seed(0)
# creates some points
pts = create_points(6)
show = True # to display a frame
save = False # to save into .png files in "figs" directory
scatter_plot(pts, [[]],
title="convex hull : initial set",
show=show,
save=save)
print("Points:", pts)
# compute the hull
#hull = exhaustive(pts, show=show, save=save)
hull = graham(pts, show=show, save=save)
#hull = jarvis(pts, show=show, save=save)
#hull = eddy_floyd(pts)
print("Hull:", hull)
scatter_plot(pts, [hull],
title="convex hull : final result",
show=True,
save=save)
def global_stiffness_matrix(nodes, triangles):
"""
Funtion for the assembly of the global stiffnes matrix.
Parameters:
-----------
nodes: numpy array of dimension (n_nodes, 3), where n_nodes is the
number of nodes forming the mesh, and the three columns
represent coordinates (x, y, z).
triangles: numpy array of dimension (n_triangles, 4), where n_nodes
is the number of nodes forming the mesh, the first is the
label that refers to the physical entity where each node
belongs. The remaining columns tell which nodes belong
to each of the vertices of the triangle
remove: List with the numbers of columns to be removed
Returns:
--------
glo_stif: Matrix like array of size (n_nodes, n_nodes). Represents
the global stiffness matrix of the system
"""
from matrices import local_stiffness_matrix
from utils import create_points, calculate_area
n_nodes = nodes.shape[0] # Number (n) of nodes
n_triangles = triangles.shape[0] # Number (n) of triangles
glo_stif = zeros((n_nodes, n_nodes))# Initiate Global (glo) stiffness matrix
for el in range(n_triangles):
pt_a, pt_b, pt_c = create_points(nodes, triangles, el)
#print pt_a, pt_b, pt_c
ln_ab = pt_b - pt_a
ln_bc = pt_c - pt_b
ln_ca = pt_a - pt_c
lines = [ln_bc, ln_ca, ln_ab]
area = calculate_area(lines)
lo_stif = local_stiffness_matrix(lines)
lo_stif = lo_stif/(4*area)
for i in range(1, lo_stif.shape[0]+1):
for j in range(1, lo_stif.shape[0]+1):
glo_stif[triangles[el, i]-1, triangles[el, j]-1] = \
glo_stif[triangles[el, i]-1, triangles[el, j]-1] + \
lo_stif[i-1,j-1]
# ^ due to python's 0 base numbering
return glo_stif
def global_mass_matrix(nodes, triangles, *remove):
"""
funtion for the ensamble of the global mass matrix
Parameters:
-----------
nodes: numpy array of dimension (n_nodes, 3), where n_nodes is the
number of nodes forming the mesh, and the three columns
represent coordinates (x, y, z).
triangles: numpy array of dimension (n_triangles, 4), where n_nodes
is the number of nodes forming the mesh, the first is the
label that refers to the physical entity where each node
belongs. The remaining columns tell which nodes belong
to each of the vertices of the triangle
remove: List with the numbers of columns to be removed
Returns:
--------
"""
from matrices import local_mass_matrix
from utils import create_points
from numpy.linalg import det
from numpy import delete
n_nodes = nodes.shape[0] # Number (n) of nodes
n_triangles = triangles.shape[0] # Number (n) of triangles
glo_mass = zeros((n_nodes, n_nodes))# Initiate Global (glo) mass matrix
tr_mat = zeros((2,2)) # Initiate the transformation (tr) matrix (mat)
for el in range(n_triangles):
pt_a, pt_b, pt_c = create_points(nodes, triangles, el)
tr_mat[:, 0] = pt_b - pt_a
tr_mat[:, 1] = pt_c - pt_a
jac = det(tr_mat)
lo_mass = local_mass_matrix()
lo_mass = jac * lo_mass # Escalate acording with the jacobian of the
# transformation
for i in range(1, lo_mass.shape[0]+1):
for j in range(1, lo_mass.shape[0]+1):
glo_mass[triangles[el, i]-1, triangles[el, j]-1] = \
glo_mass[triangles[el, i]-1, triangles[el, j]-1] + \
lo_mass[i-1,j-1]
# ^ due to python's 0 base numbering
glo_mass_d = delete(glo_mass, remove, 0)
glo_mass_d = delete(glo_mass_d, remove, 1)
return glo_mass_d
def sources_vector(nodes, triangles, remove):
"""
This function computes the l vector associated to sources in the domain
Parameters:
-----------
nodes: numpy array of dimension (n_nodes, 3), where n_nodes is the
number of nodes forming the mesh, and the three columns
represent coordinates (x, y, z).
triangles: numpy array of dimension (n_triangles, 4), where n_nodes
is the number of nodes forming the mesh, the first is the
label that refers to the physical entity where each node
belongs. The remaining columns tell which nodes belong
to each of the vertices of the triangle
Returns:
--------
l: right hand side vector of the equation associated to sources.
"""
from utils import create_points
from numpy.linalg import det
from numpy import array
n_nodes = nodes.shape[0] # Number (n) of nodes
n_triangles = triangles.shape[0] # Number (n) of triangles
glo_l = zeros(n_nodes) # Initiate global sources vector l
tr_mat = zeros((2,2)) # Initiate the transformation (tr) matrix (mat)
for el in range(n_triangles):
pt_a, pt_b, pt_c = create_points(nodes, triangles, el)
tr_mat[:, 0] = pt_b - pt_a
tr_mat[:, 1] = pt_c - pt_a
jac = det(tr_mat)
lo_l = array([1./6, 1./6, 1./6]) # This is the local (lo) l vector fo
# a standard triangular element of
# base 1 and height 1
for i in range(1, 4):
glo_l[triangles[el, i]-1] = glo_l[triangles[el, i]-1] + \
jac * lo_l[i - 1]
glo_l = delete(glo_l, remove) # Remove Dirichlet columns
return glo_l
def main():
"""
A sample main program to test our algorithms.
@return: None
"""
to=time.time()
# initialize the random generator seed to always use the same set of points
seed(0)
# creates some points
pts = create_points(1800)
show = True # to display a frame
save = False # to save into .png files in "figs" directory
scatter_plot(pts, [[]], title="convex hull : initial set", show=show, save=save)
print("Points:", pts)
# compute the hull
#hull = exhaustive(pts, show=show, save=save)
print("graham",graham(pts))
hull=graham(pts)
print("Hull:", hull)
scatter_plot(pts, [hull], title="convex hull : final result", show=True, save=save)
print("Temps d'éxecution: %s secondes" %(time.time()-to))
