def test_brute_force_middle_limit():
sites = MathUtilities.generate_points(number = 4)
plt.figure()
plt.axis('equal')
plt.scatter([point.x for point in sites], [point.y for point in sites])
brute_force_middle_limit(sites)
ax = plt.gca()
ax.set_xlim(0, 10)
ax.set_ylim(0, 10)
plt.show()
def randomForce(self, phys, seed):
"""
Compute a random (x, y, z) force.
@type phys: Physical
@param phys: The physical system.
@type seed: integer
@param seed: Random number generator seed.
@rtype: numpy.ndarray
@return: The random force as a three-element array (x,y,z)
"""
retval = numpy.ndarray(phys.numAtoms()*3)
#tmp = numpy.ndarray(3)
ff = 0
while (ff < phys.numAtoms()*3):
retval[ff] = MathUtilities.randomGaussianNumber(seed)
retval[ff+1] = MathUtilities.randomGaussianNumber(seed)
retval[ff+2] = MathUtilities.randomGaussianNumber(seed)
ff += 3
return retval
def randomForce(self, phys, seed):
"""
Compute a random (x, y, z) force.
@type phys: Physical
@param phys: The physical system.
@type seed: integer
@param seed: Random number generator seed.
@rtype: numpy.ndarray
@return: The random force as a three-element array (x,y,z)
"""
retval = numpy.ndarray(phys.numAtoms() * 3)
#tmp = numpy.ndarray(3)
ff = 0
while (ff < phys.numAtoms() * 3):
retval[ff] = MathUtilities.randomGaussianNumber(seed)
retval[ff + 1] = MathUtilities.randomGaussianNumber(seed)
retval[ff + 2] = MathUtilities.randomGaussianNumber(seed)
ff += 3
return retval
def build(self):
"""
Build the physical data.
"""
tm = -1
if (hasattr(self, "myTop")):
tm = self.myTop.time
if (self.bc == "Periodic"):
if (self.defaultCBV):
# TEMPORARY STRUCTURES USED TO COMPUTE
# BOUNDING BOX
v1 = numpy.ndarray(3)
v2 = numpy.ndarray(3)
v3 = numpy.ndarray(3)
v4 = numpy.ndarray(3)
v1.fill(sys.maxint)
v2.fill(-sys.maxint)
# BOUNDING BOX
i = 0
while (i < numpy.size(self.positions)):
if (self.positions[i] < v1[0]):
v1[0] = float(self.positions[i])
if (self.positions[i] > v2[0]):
v2[0] = float(self.positions[i])
if (self.positions[i+1] < v1[1]):
v1[1] = float(self.positions[i+1])
if (self.positions[i+1] > v2[1]):
v2[1] = float(self.positions[i+1])
if (self.positions[i+2] < v1[2]):
v1[2] = float(self.positions[i+2])
if (self.positions[i+2] > v2[2]):
v2[2] = float(self.positions[i+2])
i += 3
v4.fill(Constants.periodicBoundaryTolerance()/2.0)
v1 = v1 - v4
v2 = v2 + v4
v3 = v2 - v1
self.cB1[0] = v3[0]
self.cB2[1] = v3[1]
self.cB3[2] = v3[2]
self.cO = v1 + v3 * 0.5
self.myTop.setBC(self.cB1[0],self.cB1[1],self.cB1[2],self.cB2[0],self.cB2[1],self.cB2[2],self.cB3[0],self.cB3[1],self.cB3[2],self.cO[0],self.cO[1],self.cO[2])
self.myTop.setExclusion(self.exclude)
if (self.myPSF.numAtoms() > 0 and hasattr(self.myPAR, 'readFlag')):
GenericTopology.buildTopology(self.myTop, self.myPSF, self.myPAR, 0, self.myTop.makeSCPISM())
if (numpy.size(self.velocities) == 0):
# This function actually returns a value, since it is
# unused the runtime environment detects a memory leak.
# disown() removes this concern.
MathUtilities.randomNumber(self.seed)
# NOTE TO SELF: THIS WAS COMMENTED OUT FOR PM 3
# IT MAY EFFECT RANDOM NUMBER CONSISTENCY
#aaa = MathUtilities.randomNumberFirst(self.seed, 1)
TopologyUtilities.randomVelocity(self.temperature, self.myTop, self.velvec, self.seed)
if (self.remcom >= 0):
TopologyUtilities.removeLinearMomentum(self.velvec, self.myTop).disown()
if (self.remang >= 0):
TopologyUtilities.removeAngularMomentum(self.posvec, self.velvec, self.myTop).disown()
if (self.bc == "Periodic"):
self.myTop.setCellSize(self.cellsize)
# COMPUTE INV MASS MATRIX
temp = list()
ii = 0
while ii < self.numAtoms()*3:
temp.append(0.0)
ii += 1
ii = 0
self.invmasses.resize(self.numAtoms()*3)
while ii < self.numAtoms()*3:
im = 1.0 / self.myPSF.getMass(ii/3)
self.invmasses[ii] = im
self.invmasses[ii+1] = im
self.invmasses[ii+2] = im
ii += 3
# COMPUTE MASS MATRIX
temp = list()
ii = 0
while ii < self.numAtoms()*3:
temp.append(0.0)
ii += 1
ii = 0
self.masses.resize(self.numAtoms()*3)
while ii < self.numAtoms()*3:
m = self.myPSF.getMass(ii/3)
temp[ii] = m
self.masses[ii] = temp[ii]
temp[ii] = 0.0
temp[ii+1] = m
self.masses[ii+1] = temp[ii+1]
temp[ii+1] = 0.0
temp[ii+2] = m
self.masses[ii+2] = temp[ii+2]
temp[ii+2] = 0.0
ii += 3
# COMPUTE MASS SUM
self.masssum = 0
ii = 0
while ii < self.numAtoms():
self.masssum += self.myPSF.getMass(ii)
ii += 1
# SET SELFICAL TIME
if (tm != -1):
self.myTop.time = tm
self.dirty = 0 # clean now!
def delaunay_triangulation():
DT_triangles = []
DT_edges = []
#4 corner points
site_bottomleft = Point(0.0, 0.0)
site_topleft = Point(-2.0, 10.0)
site_bottomright = Point(10.0, 0.0)
site_topright = Point(10.0, 10.0)
site_edges = [Edge(site) for site in [site_bottomleft, site_topleft, site_bottomright, site_topright]]
for A, B, C in [site_edges[:3], site_edges[1:]]:
DT_triangles.append(DelaunayTriangle(A, B, C))
#The following line is responsible for object mismatch between triangle edges and DT edges because we instantiate again every Edge
#DT_edges.extend([Edge(site) for site in [site_bottomleft, site_topleft, site_bottomright, site_topright]])
#Add two randomly generated point to the list of point
site_edges.extend([Edge(point) for point in MathUtilities.generate_points(number = 2)])
DT_edges = site_edges[:4]
#Add next site insite the diagram
#Ignore the first 4 points
for new_site in site_edges[4:]:
new_triangles = []
triangle_queue = []
debug("DT", DT_triangles, DT_edges)
inside_triangle = False
#For each triangle check if it is inside
#source http://www.karlchenofhell.org/cppswp/lischinski.pdf
for triangle in DT_triangles:
#Check if the edge is inside triangle
if triangle.is_inside(site) and inside_triangle == False:
print "edge is inside triangle"
inside_triangle = True
new_triangles = triangle.get_inserted_triangles(new_site)
debug("right new_triangle", new_triangles, new_triangles[0].edges)
print set(DT_edges) & set(new_triangles[0].edges)
#Add new triangles to the triangulation list and remove the current one
DT_triangles.remove(triangle)
#For every new triangle created, check if any point is inside the circumcircle
#If there is one point inside, legalize the triangle
for new_triangle in new_triangles:
#Copy checked_edges list
checked_edges = DT_edges[:]
print "checked_edges"
print checked_edges
debug("new_triangle", new_triangle, new_triangle.edges)
#We need to exclude the points of the current triangle
for edge_to_remove in new_triangle.edges:
try:
print "edge to remove"
print edge_to_remove
checked_edges.remove(edge_to_remove)
print "edge removed"
except:
print "remove failed"
for checked_edge in checked_edges:
if new_triangle.is_inside_circumcircle(checked_edge):
print "site inside triangle"
left_edge, right_edge, middle_edge = new_triangle.get_ordered_edges(checked_edge)
#Flip edges to get a legal triangulation
left_triangle = DelaunayTriangle(checked_edge, left_edge, middle_edge)
right_triangle = DelaunayTriangle(checked_edge, right_edge, middle_edge)
triangle_queue.append(left_triangle)
triangle_queue.append(right_triangle)
try:
#Remove previous triangle from list
new_triangles.remove(new_triangle)
except:
print "Triangle already removed"
#Add queued triangle to DT_triangles
DT_triangles.extend(triangle_queue)
#Triangle deletion finished we can add new triangles
DT_triangles.extend(new_triangles)
#Triangle has been found, break the loop for this site
break
plt.figure()
#Special marker on the current added site
plt.plot([new_site.x], [new_site.y], marker = "*", markersize = 10)
delaunay_incremental_display(site_edges, DT_triangles)
DT_edges.append(new_site)
if inside_triangle == False:
print "This edge is not inside any triangle"
print DT_triangles
print "Job done for all sites"
