Beispiel #1
0
def plot_mesh(pts, tri, *args):
    if len(args) > 0:
        tripcolor(pts[:, 0], pts[:, 1], tri, args[0], edgecolor="black", cmap="Blues")
    else:
        triplot(pts[:, 0], pts[:, 1], tri, "k-", lw=2)
    axis("tight")
    axes().set_aspect("equal")
Beispiel #2
0
def uniform_mesh_info(ns):
    """
    A2.4 Page 69.
    """
    h = 1 / ns
    x = np.linspace(0, 1, ns + 1)
    y = np.copy(x)
    # co-ordinates of vertices
    xv, yv = np.meshgrid(x, y)
    xv = xv.ravel()
    yv = yv.ravel()
    n2 = ns * ns
    nvtx = (ns + 1) * (ns + 1)
    ne = 2 * n2
    # global vertex labels of individual elements
    elt2vert = np.zeros((ne, 3), dtype='int')
    vv = np.reshape(np.arange(0, nvtx), (ns + 1, ns + 1), order='F')
    v1 = vv[0:ns, 0:ns]
    v2 = vv[1:, 0:ns]
    v3 = vv[0:ns, 1:]
    elt2vert[0:n2, :] = np.vstack((v1.ravel(), v2.ravel(), v3.ravel())).T
    v1 = vv[1:, 1:]
    elt2vert[n2:, :] = np.vstack((v1.ravel(), v3.ravel(), v2.ravel())).T
    plt.figure(2)  #
    ch0.PlotSetup()
    plt.axis('equal')
    plt.triplot(xv.ravel(), yv.ravel(), elt2vert, 'k-')
    plt.xlabel(r'$x_1$')
    plt.ylabel(r'$x_2$')
    return xv, yv, elt2vert, nvtx, ne, h
Beispiel #3
0
def plot_tri_mesh(pts, tri):
    triplot(pts[:, 0], pts[:, 1], tri, "k-", lw=2)

    if len(pts) < 200:
        for k, p in enumerate(pts):
            text(p[0],
                 p[1],
                 "%d" % k,
                 color="black",
                 fontsize=10,
                 bbox=dict(boxstyle="round", fc="white"),
                 horizontalalignment='center',
                 verticalalignment='center')

    if len(tri) < 400:
        for k in xrange(tri.shape[0]):
            center = pts[tri[k]].sum(axis=0) / 3.0

            text(center[0],
                 center[1],
                 "%d" % k,
                 color="black",
                 fontsize=8,
                 horizontalalignment='center',
                 verticalalignment='center')
def get_distances(points):
    max_pos = points 
    tri = scipy.spatial.Delaunay(max_pos)
    pylab.triplot(max_pos[:,0], max_pos[:,1], tri.simplices.copy())
    pylab.plot(max_pos[:,0], max_pos[:,1], 'ro')
    plt.show()
    edges = []
    wholeSize = 0
    for triangle in tri.simplices:
        vertice0=max_pos[triangle[0]]
        vertice1=max_pos[triangle[1]]
        vertice2=max_pos[triangle[2]]
        """
        edge0 = math.sqrt(pow(vertice0[0] - vertice1[0], 2) + pow(vertice0[1] - vertice1[1], 2)) 
        edge1 = math.sqrt(pow(vertice1[0] - vertice2[0], 2) + pow(vertice1[1] - vertice2[1], 2)) 
        edge2 = math.sqrt(pow(vertice2[0] - vertice0[0], 2) + pow(vertice2[1] - vertice0[1], 2))
        """
        edge0 = np.linalg.norm(vertice0-vertice1)
        edge1 = np.linalg.norm(vertice2-vertice1)
        edge2 = np.linalg.norm(vertice0-vertice2)
        edges.append(edge0)
        edges.append(edge1)
        edges.append(edge2)
        wholeSize += edge0 + edge1 + edge2
    edges = np.array(edges)
    print("mean: " + str(np.mean(edges)))
    print("standard deviation: " + str(np.std(edges)))
    print("maximum: " + str(np.ndarray.max(edges)))
    print("minimum: " + str(np.ndarray.min(edges)))
    print(wholeSize)
    return edges
Beispiel #5
0
def plotmesh(pts, tri, *args, **kwargs):
    showindex = kwargs.get('index', False)
    h0 = kwargs.get('h0', 0.0)
    edges = kwargs.get('edges', np.array([]))
    if len(args) > 0:
        tripcolor(pts[:, 0],
                  pts[:, 1],
                  tri,
                  args[0],
                  edgecolor='black',
                  cmap="Blues")
    else:
        triplot(pts[:, 0], pts[:, 1], tri, "k-", lw=2)
    if showindex:
        dx = h0 / 10.0
        for i in range(np.shape(tri)[0]):  # label triangle index in green
            x = np.sum(pts[tri[i, :], 0]) / 3.0
            y = np.sum(pts[tri[i, :], 1]) / 3.0
            text(x, y, '%d' % i, color='g')
        for j in range(np.shape(pts)[0]):  # label point index in blue
            text(pts[j, 0] + dx, pts[j, 1] + dx, '%d' % j, color='b')
        if len(edges) > 0:
            for k in range(np.shape(edges)[0]):  # label edge index in red
                x = np.sum(pts[edges[k, :], 0]) / 2.0
                y = np.sum(pts[edges[k, :], 1]) / 2.0
                text(x + dx, y - dx, '%d' % k, color='r')
    axis('tight')
    axis('equal')
Beispiel #6
0
def plot_mesh(pts, tri, *args):
    if len(args) > 0:
        tripcolor(pts[:,0], pts[:,1], tri, args[0], edgecolor='black', cmap="Blues")
    else:
        triplot(pts[:,0], pts[:,1], tri, "k-", lw=2)
    axis('tight')
    axes().set_aspect('equal')
Beispiel #7
0
	def plotMesh(self):
		import pylab as plt
		import matplotlib.tri as tri
		vertexCoords = self.mesh.vertexCoords
		vertexIDs = self.mesh._orderedCellVertexIDs
		
		plt.figure(figsize=(8, 8))
		plotMesh = tri.Triangulation(vertexCoords[0], vertexCoords[1], np.transpose(vertexIDs))
		plt.triplot(plotMesh)
		plt.show()
Beispiel #8
0
    def plotMesh(self):
        import pylab as plt
        import matplotlib.tri as tri
        vertexCoords = self.mesh.vertexCoords
        vertexIDs = self.mesh._orderedCellVertexIDs

        plt.figure(figsize=(8, 8))
        plotMesh = tri.Triangulation(vertexCoords[0], vertexCoords[1],
                                     np.transpose(vertexIDs))
        plt.triplot(plotMesh)
        plt.show()
def check_metric_ellipse(width=2e-2, eta = 0.02, Nadapt=6):
    set_log_level(WARNING)
    parameters["allow_extrapolation"] = True
    
    ### CONSTANTS
    meshsz = 40
    hd = Constant(width)
    ### SETUP MESH
    mesh = RectangleMesh(Point(-0.5,-0.5),Point(0.5,0.5),1*meshsz,1*meshsz,"left/right")
    ### SETUP SOLUTION
    angle = pi/8#rand()*pi/2 
    #testsol = 'tanh(x[0]/' + str(float(hd)) + ')' #tanh(x[0]/hd)
    testsol = 'tanh((' + str(cos(angle)) + '*x[0]+'+ str(sin(angle)) + '*x[1])/' + str(float(hd)) + ')' #tanh(x[0]/hd)
    ddtestsol = str(cos(angle)+sin(angle))+'*2*'+testsol+'*(1-pow('+testsol+',2))/'+str(float(hd)**2)
    #testsol2 = 'tanh(x[1]/' + str(float(hd)) + ')' #tanh(x[0]/hd)
    testsol2 = 'tanh((' + str(cos(angle)) + '*x[1]-'+ str(sin(angle)) + '*x[0])/' + str(float(hd)) + ')' #tanh(x[0]/hd)
    ddtestsol2 = str(cos(angle)-sin(angle))+'*2*'+testsol2+'*(1-pow('+testsol2+',2))/'+str(float(hd)**2)
    def boundary(x):
          return x[0]-mesh.coordinates()[:,0].min() < DOLFIN_EPS or mesh.coordinates()[:,0].max()-x[0] < DOLFIN_EPS \
          or mesh.coordinates()[:,1].min()+0.5 < DOLFIN_EPS or mesh.coordinates()[:,1].max()-x[1] < DOLFIN_EPS  
    # PERFORM ONE ADAPTATION ITERATION
    for iii in range(Nadapt):
     V = FunctionSpace(mesh, "CG" ,2); dis = TrialFunction(V); dus = TestFunction(V); u = Function(V); u2 = Function(V)
     bc = DirichletBC(V, Expression(testsol), boundary)
     bc2 = DirichletBC(V, Expression(testsol2), boundary)
     R = interpolate(Expression(ddtestsol),V)
     R2 = interpolate(Expression(ddtestsol2),V)
     a = inner(grad(dis), grad(dus))*dx
     L = R*dus*dx
     L2 = R2*dus*dx
     solve(a == L, u, bc)
     solve(a == L2, u2, bc2)
     
     H  = metric_pnorm(u , eta, max_edge_length=1., max_edge_ratio=50); #Mp =  project(H,  TensorFunctionSpace(mesh, "CG", 1))
     H2 = metric_pnorm(u2, eta, max_edge_length=1., max_edge_ratio=50); #Mp2 = project(H2, TensorFunctionSpace(mesh, "CG", 1))
     H3 = metric_ellipse(H,H2); Mp3 = project(H3, TensorFunctionSpace(mesh, "CG", 1))
     print("H11: %0.0f, H22: %0.0f, V: %0.0f,E: %0.0f" % (assemble(abs(H3[0,0])*dx),assemble(abs(H3[1,1])*dx),mesh.num_vertices(),mesh.num_cells()))
     startTime = time()
     if iii != 6:
     # mesh2 = Mesh(adapt(Mp2))
       mesh = Mesh(adapt(Mp3))
     # mesh3 = adapt(Mp)
      
     print("total time was %0.1fs" % (time()-startTime))
    
    # PLOT MESH
    figure(1); triplot(mesh.coordinates()[:,0],mesh.coordinates()[:,1],mesh.cells()); axis('equal'); axis('off'); box('off')
    #figure(2); triplot(mesh2.coordinates()[:,0],mesh2.coordinates()[:,1],mesh2.cells()) #mesh = mesh2
    #figure(3); triplot(mesh3.coordinates()[:,0],mesh3.coordinates()[:,1],mesh3.cells()) #mesh = mesh3
    figure(4); testf = interpolate(u2,FunctionSpace(mesh,'CG',1))
    vtx2dof = vertex_to_dof_map(FunctionSpace(mesh, "CG" ,1))
    zz = testf.vector().array()[vtx2dof]; zz[zz==1] -= 1e-16
    tricontourf(mesh.coordinates()[:,0],mesh.coordinates()[:,1],mesh.cells(),zz,100)
    show()
Beispiel #10
0
def plot_mesh(pts, tri, *args):
    if len(args) > 0:
        tripcolor(pts[:, 0],
                  pts[:, 1],
                  tri,
                  args[0],
                  edgecolor='black',
                  cmap="Blues")
    else:
        triplot(pts[:, 0], pts[:, 1], tri, "k-", lw=2)
    axis('tight')
    axes().set_aspect('equal')
Beispiel #11
0
def plot_tri_mesh(pts, tri):
    triplot(pts[:,0], pts[:,1], tri, "k-", lw=2)

    if len(pts) < 200:
        for k,p in enumerate(pts):
            text(p[0], p[1], "%d" % k, color="black",
                 fontsize=10,
                 bbox=dict(boxstyle = "round", fc = "white"),
                 horizontalalignment='center', verticalalignment='center')

    if len(tri) < 400:
        for k in xrange(tri.shape[0]):
            center = pts[tri[k]].sum(axis=0) / 3.0

            text(center[0], center[1], "%d" % k, color="black",
                 fontsize=8,
                 horizontalalignment='center', verticalalignment='center')
Beispiel #12
0
 def anneal(self, T, m, epsilon, verbose=True, graphics=False, pause=False):
     step = 0
     while not self.anneal_step(m, T):
         T = (1.0 - epsilon) * T
         step += m
         if graphics or verbose:
             ilo = self.y.argsort()[0]
             ihi = self.y.argsort()[-1]
         if graphics:
             if len(gca().patches) >= 1:
                 del gca().patches[-1:]
             if len(gca().lines) >= 1:
                 del gca().lines[-1]
             triplot(ds.p[:, 0], ds.p[:, 1], 'r.--')
             draw()
             if pause:
                 raw_input('continue...')
         if verbose:
             print 'step %d temperature %f x %s y %f' % (
                 step, T, self.p[ilo, :], self.y[ilo])
Beispiel #13
0
def plotmesh(pts, tri, *args, **kwargs):
    showindex = kwargs.get('index',False)
    h0 = kwargs.get('h0',0.0)
    edges = kwargs.get('edges',np.array([]))
    if len(args) > 0:
        tripcolor(pts[:,0], pts[:,1], tri, args[0], edgecolor='black', cmap="Blues")
    else:
        triplot(pts[:,0], pts[:,1], tri, "k-", lw=2)
    if showindex:
        dx = h0/10.0
        for i in range(np.shape(tri)[0]):   # label triangle index in green
            x = np.sum(pts[tri[i,:],0]) / 3.0
            y = np.sum(pts[tri[i,:],1]) / 3.0
            text(x,y,'%d' % i, color='g')
        for j in range(np.shape(pts)[0]):   # label point index in blue
            text(pts[j,0]+dx,pts[j,1]+dx,'%d' % j, color='b')
        if len(edges) > 0:
            for k in range(np.shape(edges)[0]):   # label edge index in red
                x = np.sum(pts[edges[k,:],0]) / 2.0
                y = np.sum(pts[edges[k,:],1]) / 2.0
                text(x+dx,y-dx,'%d' % k, color='r')
    axis('tight')
    axis('equal')
Beispiel #14
0
        tf.write('\t\t</vertices>\n\t\t<cells size="%d">\n' % num_triangles)

        for i in range(0, num_triangles):
            tf.write('\t\t\t<triangle index="%d" v0="%d" v1="%d" v2="%d"/>\n'
                % (i, t[i,0], t[i,1], t[i,2]))

        tf.write('\t\t</cells>\n\t</mesh>\n</dolfin>')

# 'Testcase'
def _t_phi(x):
    """
    Signed distance function the unit circle.
    """
    return np.maximum(np.sqrt(np.sum(x*x, 1))-1.0, -np.sqrt(np.sum(x*x, 1))+0.5)

_t_bbox = np.array([[-1., -1.],[1., 1.]])

if __name__ == '__main__':
    import pylab as py
    p, t = distmesh2d(_t_phi, 0.05, _t_bbox) 

    export_xml(p, t, "unit_circle.xml")
    export_vtk(p, t, "unit_circle.vtk")
    export_pgf(p, t, "unit_circle.patches")

    py.triplot(p[:,0], p[:,1], t)
    py.show()

                         
Beispiel #15
0
#!/usr/bin/env python

import PylabUtils as plu
import pylab
from scipy.spatial import Delaunay

points = pylab.rand (200, 2)

# plot the raw points
pylab.figure ()
pylab.scatter (points[:,0], points[:,1])

# compute and show the triangulated points
tri = Delaunay (points)
pylab.figure ()
pylab.triplot(points[:,0], points[:,1], tri.simplices.copy())
pylab.plot(points[:,0], points[:,1], 'o')

# compute and show the alpha-shape
alphaInds = plu.triang.alphaShape (tri, alpha=0.2, removeNeighbors=True)
pylab.figure ()
pylab.triplot(points[:,0], points[:,1], tri.simplices[alphaInds, :].copy())
pylab.plot(points[:,0], points[:,1], 'o')

# compute and show the border ("concave hull")
(edgeX, edgeY, borderInds) = plu.triang.border (tri, inds=alphaInds)
pylab.figure ()
pylab.scatter (points[:,0], points[:,1])
plu.plotting.plotLines (edgeX, edgeY, 'r')
pylab.show ()
    pylab.title("delaunay.Triangulation: linear interp")

    # delaunay - nearest neighbors interpolation
    pylab.subplot(2, 2, 3, sharex=ax1, sharey=ax1)
    d = tri_to_delaunay(mt)
    nn_interp = d.nn_interpolator(vals)
    nn_field = nn_interp[0.0:1.0:100j, 0.0:1.0:100j]
    pylab.imshow(nn_field, origin="lower", extent=[0, 1, 0, 1], interpolation="nearest")
    pylab.title("delaunay.Triangulation: nearest_nbr interp")

    # make the full rounds and show topology
    pylab.subplot(2, 2, 4, sharex=ax1, sharey=ax1)
    d = tri_to_delaunay(mt)
    if CGAL:
        cg = delaunay_to_cgal(d)
        # just for fun, insert one constrained edge -
        ll = np.argmin(d.x + d.y)
        ur = np.argmax(d.x + d.y)
        cg.insert_constraint(cg.vh[ll], cg.vh[ur])
        mt3 = cgal_to_tri(cg)
        pylab.title("With and without constrained edge")
    else:
        mt3 = delaunay_to_tri(d)
        pylab.title("Roundtrip to delaunay and back")

    pylab.triplot(mt, lw=2.0, color="b")
    pylab.triplot(mt3, color="r", lw=1.0)
    pylab.axis("equal")

    pylab.show()
Beispiel #17
0
#!/usr/bin/env python

import PylabUtils as plu
import pylab
from scipy.spatial import Delaunay

points = pylab.rand(200, 2)

# plot the raw points
pylab.figure()
pylab.scatter(points[:, 0], points[:, 1])

# compute and show the triangulated points
tri = Delaunay(points)
pylab.figure()
pylab.triplot(points[:, 0], points[:, 1], tri.simplices.copy())
pylab.plot(points[:, 0], points[:, 1], 'o')

# compute and show the alpha-shape
alphaInds = plu.triang.alphaShape(tri, alpha=0.2, removeNeighbors=True)
pylab.figure()
pylab.triplot(points[:, 0], points[:, 1], tri.simplices[alphaInds, :].copy())
pylab.plot(points[:, 0], points[:, 1], 'o')

# compute and show the border ("concave hull")
(edgeX, edgeY, borderInds) = plu.triang.border(tri, inds=alphaInds)
pylab.figure()
pylab.scatter(points[:, 0], points[:, 1])
plu.plotting.plotLines(edgeX, edgeY, 'r')
pylab.show()
def minimal_example(width=2e-2, Nadapt=10, eta = 0.01):
    ### CONSTANTS
    meshsz = 40
    hd = Constant(width)
    ### SETUP MESH
    mesh = RectangleMesh(Point(-0.5,-0.5),Point(0.5,0.5),1*meshsz,1*meshsz,"left/right")
    ### DERIVE FORCING TERM
    angle = pi/8 #rand*pi/2
    sx = Symbol('sx'); sy = Symbol('sy'); width_ = Symbol('ww'); aa = Symbol('aa')
    testsol = pytanh((sx*pycos(aa)+sy*pysin(aa))/width_)
    ddtestsol = str(diff(testsol,sx,sx)+diff(testsol,sy,sy)).replace('sx','x[0]').replace('sy','x[1]')
    #replace ** with pow
    ddtestsol = ddtestsol.replace('tanh((x[0]*sin(aa) + x[1]*cos(aa))/ww)**2','pow(tanh((x[0]*sin(aa) + x[1]*cos(aa))/ww),2.)')
    ddtestsol = ddtestsol.replace('cos(aa)**2','pow(cos(aa),2.)').replace('sin(aa)**2','pow(sin(aa),2.)').replace('ww**2','(ww*ww)')
    #insert vaulues
    ddtestsol = ddtestsol.replace('aa',str(angle)).replace('ww',str(width))
    testsol = str(testsol).replace('sx','x[0]').replace('sy','x[1]').replace('aa',str(angle)).replace('ww',str(width))
    ddtestsol = "-("+ddtestsol+")"
    def boundary(x):
          return x[0]-mesh.coordinates()[:,0].min() < DOLFIN_EPS or mesh.coordinates()[:,0].max()-x[0] < DOLFIN_EPS \
          or mesh.coordinates()[:,1].min()+0.5 < DOLFIN_EPS or mesh.coordinates()[:,1].max()-x[1] < DOLFIN_EPS  
    # PERFORM TEN ADAPTATION ITERATIONS
    for iii in range(Nadapt):
     V = FunctionSpace(mesh, "CG" ,2); dis = TrialFunction(V); dus = TestFunction(V); u = Function(V)
     a = inner(grad(dis), grad(dus))*dx
     L = Expression(ddtestsol)*dus*dx
     bc = DirichletBC(V, Expression(testsol), boundary)
     solve(a == L, u, bc)
     startTime = time()
     H = metric_pnorm(u, eta, max_edge_length=3., max_edge_ratio=None)
     H = logproject(H)
     if iii != Nadapt-1:
      mesh = adapt(H)
      L2error = errornorm(Expression(testsol), u, degree_rise=4, norm_type='L2')
      log(INFO+1,"total (adapt+metric) time was %0.1fs, L2error=%0.0e, nodes: %0.0f" % (time()-startTime,L2error,mesh.num_vertices()))
    
    #    # PLOT MESH
#    figure()
    coords = mesh.coordinates().transpose()
#    triplot(coords[0],coords[1],mesh.cells(),linewidth=0.1)
#    #savefig('mesh.png',dpi=300) #savefig('mesh.eps'); 
            
    figure() #solution
    testf = interpolate(Expression(testsol),FunctionSpace(mesh,'CG',1))
    vtx2dof = vertex_to_dof_map(FunctionSpace(mesh, "CG" ,1))
    zz = testf.vector().array()[vtx2dof]
    hh=tricontourf(coords[0],coords[1],mesh.cells(),zz,100)
    colorbar(hh)
#    savefig('solution.png',dpi=300) #savefig('solution.eps'); 
    
    figure() #analytical solution
    testfe = interpolate(u,FunctionSpace(mesh,'CG',1))
    zz = testfe.vector().array()[vtx2dof]
    hh=tricontourf(coords[0],coords[1],mesh.cells(),zz,100)
    colorbar(hh)
    #savefig('analyt.png',dpi=300) #savefig('analyt.eps');
    
    figure() #error
    zz -= testf.vector().array()[vtx2dof]; zz[zz==1] -= 1e-16
    hh=tricontourf(mesh.coordinates()[:,0],mesh.coordinates()[:,1],mesh.cells(),zz,100,cmap=get_cmap('binary'))
    colorbar(hh)

    hold('on'); triplot(mesh.coordinates()[:,0],mesh.coordinates()[:,1],mesh.cells(),color='r',linewidth=0.5); hold('off')
    axis('equal'); box('off'); title('error')
    show()
                plt.imshow(dataset_queenframe)
                plt.show()

            magn = dataset_queenframe
            print(dataset_cleanqueen.value)
            values, counts = np.unique(dataset_cleanqueen, return_counts=True)
            print(counts)

            #counts = counts/100000
            counts = np.array(np.delete(counts,0))
            max_pos = scipy.ndimage.center_of_mass(magn, labels=dataset_cleanqueen.value, index = np.arange(1, dataset_cleanqueen.value.max() + 1))
            max_pos = np.array(max_pos, int)
            plt.scatter(max_pos[:,1], max_pos[:,0])
            plt.show()
            tri = scipy.spatial.Delaunay(max_pos)
            pylab.triplot(max_pos[:,1], max_pos[:,0], tri.simplices.copy())
            pylab.plot(max_pos[:,1], max_pos[:,0], 'ro')
            plt.show()
            wholeSize = 0
            for triangle in tri.simplices:
                vertice0=max_pos[triangle[0]]
                vertice1=max_pos[triangle[1]]
                vertice2=max_pos[triangle[2]]

                edge0 = math.sqrt(pow(vertice0[0] - vertice1[0], 2) + pow(vertice0[1] - vertice1[1], 2)) 
                edge1 = math.sqrt(pow(vertice1[0] - vertice2[0], 2) + pow(vertice1[1] - vertice2[1], 2)) 
                edge2 = math.sqrt(pow(vertice2[0] - vertice0[0], 2) + pow(vertice2[1] - vertice0[1], 2))
                wholeSize += edge0 + edge1 + edge2

            print(wholeSize)
def check_metric_ellipse(width=2e-2, eta=0.02, Nadapt=6):
    set_log_level(WARNING)
    parameters["allow_extrapolation"] = True

    ### CONSTANTS
    meshsz = 40
    hd = Constant(width)
    ### SETUP MESH
    mesh = RectangleMesh(-0.5, -0.5, 0.5, 0.5, 1 * meshsz, 1 * meshsz,
                         "left/right")
    ### SETUP SOLUTION
    angle = pi / 8  #rand()*pi/2
    #testsol = 'tanh(x[0]/' + str(float(hd)) + ')' #tanh(x[0]/hd)
    testsol = 'tanh((' + str(cos(angle)) + '*x[0]+' + str(
        sin(angle)) + '*x[1])/' + str(float(hd)) + ')'  #tanh(x[0]/hd)
    ddtestsol = str(cos(angle) + sin(angle)
                    ) + '*2*' + testsol + '*(1-pow(' + testsol + ',2))/' + str(
                        float(hd)**2)
    #testsol2 = 'tanh(x[1]/' + str(float(hd)) + ')' #tanh(x[0]/hd)
    testsol2 = 'tanh((' + str(cos(angle)) + '*x[1]-' + str(
        sin(angle)) + '*x[0])/' + str(float(hd)) + ')'  #tanh(x[0]/hd)
    ddtestsol2 = str(cos(angle) - sin(
        angle)) + '*2*' + testsol2 + '*(1-pow(' + testsol2 + ',2))/' + str(
            float(hd)**2)

    def boundary(x):
        return x[0]-mesh.coordinates()[:,0].min() < DOLFIN_EPS or mesh.coordinates()[:,0].max()-x[0] < DOLFIN_EPS \
        or mesh.coordinates()[:,1].min()+0.5 < DOLFIN_EPS or mesh.coordinates()[:,1].max()-x[1] < DOLFIN_EPS

    # PERFORM ONE ADAPTATION ITERATION
    for iii in range(Nadapt):
        V = FunctionSpace(mesh, "CG", 2)
        dis = TrialFunction(V)
        dus = TestFunction(V)
        u = Function(V)
        u2 = Function(V)
        bc = DirichletBC(V, Expression(testsol), boundary)
        bc2 = DirichletBC(V, Expression(testsol2), boundary)
        R = interpolate(Expression(ddtestsol), V)
        R2 = interpolate(Expression(ddtestsol2), V)
        a = inner(grad(dis), grad(dus)) * dx
        L = R * dus * dx
        L2 = R2 * dus * dx
        solve(a == L, u, bc)
        solve(a == L2, u2, bc2)

        H = metric_pnorm(u, eta, max_edge_length=1., max_edge_ratio=50)
        #Mp =  project(H,  TensorFunctionSpace(mesh, "CG", 1))
        H2 = metric_pnorm(u2, eta, max_edge_length=1., max_edge_ratio=50)
        #Mp2 = project(H2, TensorFunctionSpace(mesh, "CG", 1))
        H3 = metric_ellipse(H, H2)
        Mp3 = project(H3, TensorFunctionSpace(mesh, "CG", 1))
        print("H11: %0.0f, H22: %0.0f, V: %0.0f,E: %0.0f" %
              (assemble(abs(H3[0, 0]) * dx), assemble(
                  abs(H3[1, 1]) * dx), mesh.num_vertices(), mesh.num_cells()))
        startTime = time()
        if iii != 6:
            # mesh2 = Mesh(adapt(Mp2))
            mesh = Mesh(adapt(Mp3))
        # mesh3 = adapt(Mp)

        print("total time was %0.1fs" % (time() - startTime))

    # PLOT MESH
    figure(1)
    triplot(mesh.coordinates()[:, 0],
            mesh.coordinates()[:, 1], mesh.cells())
    axis('equal')
    axis('off')
    box('off')
    #figure(2); triplot(mesh2.coordinates()[:,0],mesh2.coordinates()[:,1],mesh2.cells()) #mesh = mesh2
    #figure(3); triplot(mesh3.coordinates()[:,0],mesh3.coordinates()[:,1],mesh3.cells()) #mesh = mesh3
    figure(4)
    testf = interpolate(u2, FunctionSpace(mesh, 'CG', 1))
    vtx2dof = vertex_to_dof_map(FunctionSpace(mesh, "CG", 1))
    zz = testf.vector().array()[vtx2dof]
    zz[zz == 1] -= 1e-16
    tricontourf(mesh.coordinates()[:, 0],
                mesh.coordinates()[:, 1], mesh.cells(), zz, 100)
    show()
def ellipse_convergence(asp=2,width=1e-2, Nadapt=10, eta_list=0.04*pyexp2(-array(range(15))*pylog(2)/2), \
use_adapt=True, problem=2, outname='', CGorderL = [2, 3], noplot=False, octaveimpl=False):
    ### SETUP SOLUTION
    sx = Symbol('sx'); sy = Symbol('sy'); width_ = Symbol('ww'); asp_ = Symbol('a')
    rrpy = pysqrt(sx*sx/asp_+sy*sy*asp_)
    if problem == 2:
        stepfunc = 0.5+165./104./width_*(rrpy-0.25)-20./13./width_**3*(rrpy-0.25)**3-102./13./width_**5*(rrpy-0.25)**5+240./13./width_**7*(rrpy-0.25)**7
    elif problem == 1:
        stepfunc = 0.5+15./8./width_*(rrpy-0.25)-5./width_**3*(rrpy-0.25)**3+6./width_**5*(rrpy-0.25)**5 
    else:
        stepfunc = 0.5+1.5/width_*(rrpy-0.25)-2/width_**3*(rrpy-0.25)**3

    ddstepfunc = str(diff(stepfunc,sx,sx)+diff(stepfunc,sy,sy)).replace('sx','x[0]').replace('sy','x[1]').replace('x[0]**2','(x[0]*x[0])').replace('x[1]**2','(x[1]*x[1])')
    stepfunc = str(stepfunc).replace('sx','x[0]').replace('sy','x[1]').replace('x[0]**2','(x[0]*x[0])').replace('x[1]**2','(x[1]*x[1])')
    #REPLACE ** with pow
    stepfunc   = stepfunc.replace('(a*(x[1]*x[1]) + (x[0]*x[0])/a)**(1/2)','sqrt(a*(x[1]*x[1]) + (x[0]*x[0])/a)')
    ddstepfunc = ddstepfunc.replace('(a*(x[1]*x[1]) + (x[0]*x[0])/a)**(1/2)','sqrt(a*(x[1]*x[1]) + (x[0]*x[0])/a)')
    ddstepfunc = ddstepfunc.replace('(a*(x[1]*x[1]) + (x[0]*x[0])/a)**(3/2)','pow(a*x[1]*x[1]+x[0]*x[0]/a,1.5)')
    ddstepfunc = ddstepfunc.replace('(sqrt(a*(x[1]*x[1]) + (x[0]*x[0])/a) - 0.25)**2','pow(sqrt(a*x[1]*x[1]+x[0]*x[0]/a) - 0.25,2.)')
    ddstepfunc = ddstepfunc.replace('(sqrt(a*(x[1]*x[1]) + (x[0]*x[0])/a) - 0.25)**3','pow(sqrt(a*x[1]*x[1]+x[0]*x[0]/a) - 0.25,3.)')
    ddstepfunc = ddstepfunc.replace('(sqrt(a*(x[1]*x[1]) + (x[0]*x[0])/a) - 0.25)**4','pow(sqrt(a*x[1]*x[1]+x[0]*x[0]/a) - 0.25,4.)')
    ddstepfunc = ddstepfunc.replace('(sqrt(a*(x[1]*x[1]) + (x[0]*x[0])/a) - 0.25)**5','pow(sqrt(a*x[1]*x[1]+x[0]*x[0]/a) - 0.25,5.)')
    ddstepfunc = ddstepfunc.replace('(sqrt(a*(x[1]*x[1]) + (x[0]*x[0])/a) - 0.25)**6','pow(sqrt(a*x[1]*x[1]+x[0]*x[0]/a) - 0.25,6.)')
    stepfunc   = stepfunc.replace('(sqrt(a*(x[1]*x[1]) + (x[0]*x[0])/a) - 0.25)**3','pow(sqrt(a*x[1]*x[1] + x[0]*x[0]/a) - 0.25,3.)')
    stepfunc   = stepfunc.replace('(sqrt(a*(x[1]*x[1]) + (x[0]*x[0])/a) - 0.25)**5','pow(sqrt(a*x[1]*x[1] + x[0]*x[0]/a) - 0.25,5.)')
    stepfunc   = stepfunc.replace('(sqrt(a*(x[1]*x[1]) + (x[0]*x[0])/a) - 0.25)**7','pow(sqrt(a*x[1]*x[1] + x[0]*x[0]/a) - 0.25,7.)')
    testsol   = '(0.25-ww/2<sqrt(x[0]*x[0]/a+x[1]*x[1]*a) && sqrt(x[0]*x[0]/a+x[1]*x[1]*a) < 0.25+ww/2 ? (' + stepfunc   + ') : 0) + (0.25+ww/2<sqrt(x[0]*x[0]/a+x[1]*x[1]*a) ? 1 : 0)'
#        testsol   = '(0.25-ww/2<sqrt(x[0]*x[0]+x[1]*x[1]) && sqrt(x[0]*x[0]+x[1]*x[1]) < 0.25+ww/2 ? (' + stepfunc   + ')) : (0.25<sqrt(x[0]*x[0]+x[1]*x[1]) ? 1 : 0)'
    ddtestsol =  '0.25-ww/2<sqrt(x[0]*x[0]/a+x[1]*x[1]*a) && sqrt(x[0]*x[0]/a+x[1]*x[1]*a) < 0.25+ww/2 ? (' + ddstepfunc + ') : 0' 
    
#        A = array([[0.5,0.5**3,0.5**5],[1,3*0.5**2,5*0.5**4],[0,6*0.5,20*0.5**3]]); b = array([0.5,0,0])
#        from numpy.linalg import solve as pysolve #15/8,-5,6
#        X = pysolve(A,b); from numpy import linspace; xx = linspace(-0.5,0.5,100)
#        from pylab import plot as pyplot; pyplot(xx,X[0]*xx+X[1]*xx**3+X[2]*xx**5,'-b')
#        rrpy = pysqrt(sx*sx+sy*sy)
#        
#        ddstepfunc = str(diff(stepfunc,sx,sx)+diff(stepfunc,sy,sy)).replace('sx','x[0]').replace('sy','x[1]').replace('x[0]**2','(x[0]*x[0])').replace('x[1]**2','(x[1]*x[1])')
#        stepfunc = str(stepfunc).replace('sx','x[0]').replace('sy','x[1]').replace('x[0]**2','(x[0]*x[0])').replace('x[1]**2','(x[1]*x[1])')
#        #REPLACE ** with pow
#        ddstepfunc = ddstepfunc.replace('(a*(x[1]*x[1]) + (x[0]*x[0])/a)**(3/2)','pow(a*x[1]*x[1]+x[0]*x[0]/a,1.5)')
#        ddstepfunc = ddstepfunc.replace('(sqrt(a*(x[1]*x[1]) + (x[0]*x[0])/a) - 0.25)**2','pow(sqrt(a*x[1]*x[1]+x[0]*x[0]/a) - 0.25,2.)')
#        ddstepfunc = ddstepfunc.replace('(sqrt(a*(x[1]*x[1]) + (x[0]*x[0])/a) - 0.25)**3','pow(sqrt(a*x[1]*x[1]+x[0]*x[0]/a) - 0.25,3.)')
#        ddstepfunc = ddstepfunc.replace('(sqrt(a*(x[1]*x[1]) + (x[0]*x[0])/a) - 0.25)**4','pow(sqrt(a*x[1]*x[1]+x[0]*x[0]/a) - 0.25,4.)')
#        stepfunc   = stepfunc.replace('(sqrt(a*(x[1]*x[1]) + (x[0]*x[0])/a) - 0.25)**3','pow(sqrt(a*x[1]*x[1]+x[0]*x[0]/a) - 0.25,3.)')
#        stepfunc   = stepfunc.replace('(sqrt(a*(x[1]*x[1]) + (x[0]*x[0])/a) - 0.25)**5','pow(sqrt(a*x[1]*x[1]+x[0]*x[0]/a) - 0.25,5.)')
#        testsol   = '(0.25-ww/2<sqrt(x[0]*x[0]+x[1]*x[1]) && sqrt(x[0]*x[0]+x[1]*x[1]) < 0.25+ww/2 ? (' + stepfunc   + ') : 0) + (0.25+ww/2<sqrt(x[0]*x[0]+x[1]*x[1]) ? 1 : 0)'
##        testsol   = '(0.25-ww/2<sqrt(x[0]*x[0]+x[1]*x[1]) && sqrt(x[0]*x[0]+x[1]*x[1]) < 0.25+ww/2 ? (' + stepfunc   + ')) : (0.25<sqrt(x[0]*x[0]+x[1]*x[1]) ? 1 : 0)'
#        ddtestsol =  '0.25-ww/2<sqrt(x[0]*x[0]+x[1]*x[1]) && sqrt(x[0]*x[0]+x[1]*x[1]) < 0.25+ww/2 ? (' + ddstepfunc + ') : 0' 
#    else: # problem == 0:
#        rrpy = pysqrt(sx*sx+sy*sy)
#         #'if(t<2*WeMax,0,if(t<4*WeMax,0.5+3/2/(2*WeMax)*(t-3*WeMax)-2/(2*WeMax)^3*(t-3*WeMax)^3,1))'; %0.5+3/2/dx*(x-xc)-2/dx^3*(x-xc)^3
#        ddstepfunc = str(diff(stepfunc,sx,sx)+diff(stepfunc,sy,sy)).replace('sx','x[0]').replace('sy','x[1]').replace('x[0]**2','(x[0]*x[0])').replace('x[1]**2','(x[1]*x[1])')
#        stepfunc = str(stepfunc).replace('sx','x[0]').replace('sy','x[1]').replace('x[0]**2','(x[0]*x[0])').replace('x[1]**2','(x[1]*x[1])')
#        #REPLACE ** with pow
#        ddstepfunc = ddstepfunc.replace('(sqrt(a*(x[1]*x[1]) + (x[0]*x[0])/a) - 0.25)**2','pow(sqrt(a*(x[1]*x[1]) + (x[0]*x[0])/a) - 0.25,2.)')
#        ddstepfunc = ddstepfunc.replace('(a*(x[1]*x[1]) + (x[0]*x[0])/a)**(3/2)','pow(a*(x[1]*x[1]) + (x[0]*x[0])/a,1.5)')
#        stepfunc = stepfunc.replace('(sqrt(a*(x[1]*x[1]) + (x[0]*x[0])/a) - 0.25)**3','pow(sqrt(a*(x[1]*x[1]) + (x[0]*x[0])/a) - 0.25,3.)')
#        testsol   = '0.25-ww/2<sqrt(x[0]*x[0]+x[1]*x[1]) && sqrt(x[0]*x[0]+x[1]*x[1]) < 0.25+ww/2 ? (' + stepfunc   + ') : (0.25<sqrt(x[0]*x[0]+x[1]*x[1]) ? 1 : 0)'
#        ddtestsol = '0.25-ww/2<sqrt(x[0]*x[0]+x[1]*x[1]) && sqrt(x[0]*x[0]+x[1]*x[1]) < 0.25+ww/2 ? (' + ddstepfunc + ') : 0' 
   
    ddtestsol = ddtestsol.replace('a**2','(a*a)').replace('ww**2','(ww*ww)').replace('ww**3','pow(ww,3.)').replace('ww**4','pow(ww,4.)').replace('ww**5','pow(ww,5.)').replace('ww**6','pow(ww,6.)').replace('ww**7','pow(ww,7.)')
    testsol = testsol.replace('ww**2','(ww*ww)').replace('ww**3','pow(ww,3.)').replace('ww**5','pow(ww,5.)').replace('ww**7','pow(ww,7.)')
    ddtestsol = ddtestsol.replace('ww',str(width)).replace('a',str(asp))
    testsol = testsol.replace('ww',str(width)).replace('a',str(asp))
    ddtestsol = '-('+ddtestsol+')'
   
    def boundary(x):
          return x[0]+0.5 < DOLFIN_EPS or 0.5-x[0] < DOLFIN_EPS or x[1]+0.5 < DOLFIN_EPS or 0.5-x[1] < DOLFIN_EPS  
    
    for CGorder in CGorderL:
        dofs = []
        L2errors = []
        #for eta in [0.16, 0.08, 0.04, 0.02, 0.01, 0.005, 0.0025] #, 0.0025/2, 0.0025/4, 0.0025/8]: #
        for eta in eta_list:
            ### SETUP MESH
            meshsz = int(round(80*0.005/(eta*(bool(use_adapt)==False)+0.05*(bool(use_adapt)==True))))
            if (not bool(use_adapt)) and meshsz > 80:
                continue
            
            mesh = RectangleMesh(-0.0,-0.0,0.5*sqrt(asp),0.5/sqrt(asp),meshsz,meshsz,"left/right")
            # PERFORM TEN ADAPTATION ITERATIONS
            for iii in range(Nadapt):
             V = FunctionSpace(mesh, "CG", CGorder); dis = TrialFunction(V); dus = TestFunction(V); u = Function(V)
             #V2 = FunctionSpace(mesh, "CG", CGorder+2)
             R = Expression(ddtestsol) #interpolate(Expression(ddtestsol),V2)
             a = inner(grad(dis), grad(dus))*dx
             L = R*dus*dx
             bc = DirichletBC(V, Expression(testsol), boundary) #Constant(0.)
             solve(a == L, u, bc)
             if not bool(use_adapt):
                 break
             H = metric_pnorm(u, eta, max_edge_ratio=1+49*(use_adapt!=2), p=2)
             H = logproject(H)
             if iii != Nadapt-1:
              mesh = adapt(H, octaveimpl=octaveimpl, debugon=False)
            
            L2error = errornorm(Expression(testsol), u, degree_rise=CGorder+2, norm_type='L2')
            dofs.append(len(u.vector().array()))
            L2errors.append(L2error)
            log(INFO+1,"%1dX ADAPT<->SOLVE complete: DOF=%5d, error=%0.0e" % (Nadapt, dofs[len(dofs)-1], L2error))
        
        # PLOT MESH + solution
        figure()
        testf  = interpolate(u                  ,FunctionSpace(mesh,'CG',1))
        testfe = interpolate(Expression(testsol),FunctionSpace(mesh,'CG',1))
        vtx2dof = vertex_to_dof_map(FunctionSpace(mesh, "CG" ,1))
        zz = testf.vector().array()[vtx2dof]; zz[zz==1] -= 1e-16
        hh=tricontourf(mesh.coordinates()[:,0],mesh.coordinates()[:,1],mesh.cells(),zz,100,cmap=get_cmap('binary'))
        colorbar(hh)
        axis('equal'); axis('off'); box('off'); xlim([0,0.5*sqrt(asp)]); ylim([0, 0.5/sqrt(asp)]); savefig('solution.png',dpi=300)
        figure()
        hold('on'); triplot(mesh.coordinates()[:,0],mesh.coordinates()[:,1],mesh.cells(),color='r',linewidth=0.5); hold('off')
        axis('equal'); box('off')
        axis('off'); xlim([0,0.5*sqrt(asp)]); ylim([0, 0.5/sqrt(asp)])
        savefig(outname+'final_mesh_CG2.png',dpi=300) #; savefig('outname+final_mesh_CG2.eps',dpi=300)
        #PLOT ERROR
        figure()
        zz = pyabs(testf.vector().array()-testfe.vector().array())[vtx2dof]; zz[zz==1] -= 1e-16
        hh=tricontourf(mesh.coordinates()[:,0],mesh.coordinates()[:,1],mesh.cells(),zz,100,cmap=get_cmap('binary'))
        colorbar(hh); axis('equal'); box('off'); title('error')
        # PLOT L2error graph
        figure()
        pyloglog(dofs,L2errors,'-b.',linewidth=2,markersize=16); xlabel('Degree of freedoms'); ylabel('L2 error')
        # SAVE SOLUTION
        dofs = array(dofs); L2errors = array(L2errors)
        fid = open("DOFS_L2errors_CG"+str(CGorder)+outname+".mpy",'w')
        pickle.dump([dofs,L2errors],fid)
        fid.close();
    
    #LOAD SAVED SOLUTIONS
    fid = open("DOFS_L2errors_CG2"+outname+".mpy",'r')
    [dofs,L2errors] = pickle.load(fid)
    fid.close()
    
    # PERFORM FITS ON LAST THREE POINTS
    NfitP = 9
    I = array(range(len(dofs)-NfitP,len(dofs)))
    slope,ints   = polyfit(pylog(dofs[I]), pylog(L2errors[I]), 1) 
    if slope < -0.7:
     fid = open("DOFS_L2errors_CG2_fit"+outname+".mpy",'w')
     pickle.dump([dofs,L2errors,slope,ints],fid)
     fid.close()
     log(INFO+1,'succes')
    else:
     os.system('rm '+outname+'.lock')
     log(INFO+1,'fail')
    #PLOT THEM TOGETHER
    if CGorderL != [2]:
     fid = open("DOFS_L2errors_CG3.mpy",'r')
     [dofs_old,L2errors_old] = pickle.load(fid)
     fid.close()
     slope2,ints2 = polyfit(pylog(dofs_old[I]), pylog(L2errors_old[I]), 1) 
     figure()
     pyloglog(dofs,L2errors,'-b.',dofs_old,L2errors_old,'--b.',linewidth=2,markersize=16)
     hold('on'); pyloglog(dofs,pyexp2(ints)*dofs**slope,'-r',dofs_old,pyexp2(ints2)*dofs_old**slope2,'--r',linewidth=1); hold('off')
     xlabel('Degree of freedoms'); ylabel('L2 error')
     legend(['CG2','CG3',"%0.2f*log(DOFs)" % slope, "%0.2f*log(DOFs)" % slope2]) #legend(['new data','old_data'])
#     savefig('comparison.png',dpi=300) #savefig('comparison.eps'); 
    if not noplot:
     show()
Beispiel #22
0
import matplotlib.tri as mtri

print((X.shape))
print((X.size))
points = np.zeros((X.size, 2))
points[:, 0] = X.reshape(X.size)
points[:, 1] = Y.reshape(Y.size)
tess = Delaunay(points)
tri = tess.vertices  # or tess.simplices depending on scipy version
triang = mtri.Triangulation(x=points[:, 0], y=points[:, 1], triangles=tri)
#

pl.contourf(X, Y, Xi1)
pl.colorbar()
# pl.scatter(X,Y,marker='-')
pl.triplot(triang, lw=0.5, color="white")
pl.axis("equal")
pl.title("SCALED MESH : chi1 with arbitrary degree and general hex mesh")
pl.show(block=True)

# ****************++

# Xi1 = boxspline(X,Y,1)


# from mpl_toolkits.mplot3d import Axes3D
# from matplotlib import cm
# from matplotlib.ticker import LinearLocator, FormatStrFormatter
# import matplotlib.pyplot as plt
# import numpy as np
Beispiel #23
0
from PIL import Image
from scipy import ndimage
import numpy as np
import pylab as plt
import matplotlib.tri as md

"""
Delaunay triangulation as described in the book doesn't seem to work anymore.
This instead uses the Triangulation function in the matplotlib.tri library.
https://codeloop.org/python-matplotlib-plotting-triangulation/
https://matplotlib.org/3.1.0/api/tri_api.html
"""

x,y = np.array(np.random.standard_normal((2,100)))
"""
I'm not sure how this "triangles" output works. It does contain an array "triangles" that
contains arrays of 3 integers. My guess is the three integers are the indices of the input
x,y arrays that correspond to the 3 vertices of the triangle.
"""
triangles = md.Triangulation(x,y)

plt.figure()
# https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.triplot.html
plt.triplot(triangles)
plt.axis('off')
plt.show()
Beispiel #24
0
def maximal_example(eta_list=array([0.001]), Nadapt=5, timet=1.,
                    period=2 * pi):
    ### CONSTANTS

    ### SETUP SOLUTION
    #testsol = '0.1*sin(50*x+2*pi*t/T)+atan(-0.1/(2*x - sin(5*y+2*pi*t/T)))';
    sx = Symbol('sx')
    sy = Symbol('sy')
    sT = Symbol('sT')
    st = Symbol('st')
    spi = Symbol('spi')
    testsol = 0.1 * pysin(50 * sx + 2 * spi * st / sT) + pyatan(
        -0.1, 2 * sx - pysin(5 * sy + 2 * spi * st / sT))
    ddtestsol = str(diff(testsol, sx, sx) + diff(testsol, sy, sy)).replace(
        'sx', 'x[0]').replace('sy', 'x[1]').replace('spi', 'pi')

    # replacing **P with pow(,P)
    ddtestsol = ddtestsol.replace("(2*x[0] - sin(5*x[1] + 2*pi*st/sT))**2",
                                  "pow(2*x[0] - sin(5*x[1] + 2*pi*st/sT),2.)")
    ddtestsol = ddtestsol.replace("cos(5*x[1] + 2*pi*st/sT)**2",
                                  "pow(cos(5*x[1] + 2*pi*st/sT),2.)")
    ddtestsol = ddtestsol.replace(
        "(pow(2*x[0] - sin(5*x[1] + 2*pi*st/sT),2.) + 0.01)**2",
        "pow((pow(2*x[0] - sin(5*x[1] + 2*pi*st/sT),2.) + 0.01),2.)")
    ddtestsol = ddtestsol.replace(
        "(1 + 0.01/pow(2*x[0] - sin(5*x[1] + 2*pi*st/sT),2.))**2",
        "pow(1 + 0.01/pow(2*x[0] - sin(5*x[1] + 2*pi*st/sT),2.),2.)")
    ddtestsol = ddtestsol.replace("(2*x[0] - sin(5*x[1] + 2*pi*st/sT))**5",
                                  "pow(2*x[0] - sin(5*x[1] + 2*pi*st/sT),5.)")
    #insert values
    ddtestsol = ddtestsol.replace('sT', str(period)).replace('st', str(timet))
    testsol = str(testsol).replace('sx', 'x[0]').replace('sy', 'x[1]').replace(
        'spi', 'pi').replace('sT', str(period)).replace('st', str(timet))
    ddtestsol = "-(" + ddtestsol + ")"

    error_list = []
    dof_list = []
    for eta in eta_list:
        meshsz = 40
        ### SETUP MESH
        #   mesh = RectangleMesh(0.4,-0.1,0.6,0.3,1*meshsz,1*meshsz,"left/right") #shock
        #   mesh = RectangleMesh(-0.75,-0.3,-0.3,0.5,1*meshsz,1*meshsz,"left/right") #waves
        mesh = RectangleMesh(-1.5, -0.25, 0.5, 0.75, 1 * meshsz, 1 * meshsz,
                             "left/right")  #shock+waves

        def boundary(x):
            return near(x[0],mesh.coordinates()[:,0].min()) or near(x[0],mesh.coordinates()[:,0].max()) \
            or near(x[1],mesh.coordinates()[:,1].min()) or near(x[1],mesh.coordinates()[:,1].max())

        # PERFORM ONE ADAPTATION ITERATION
        for iii in range(Nadapt):
            startTime = time()
            V = FunctionSpace(mesh, "CG", 2)
            dis = TrialFunction(V)
            dus = TestFunction(V)
            u = Function(V)
            #     R = interpolate(Expression(ddtestsol),V)
            a = inner(grad(dis), grad(dus)) * dx
            L = Expression(ddtestsol) * dus * dx  #
            bc = DirichletBC(V, Expression(testsol), boundary)
            solve(a == L, u, bc)
            soltime = time() - startTime

            startTime = time()
            H = metric_pnorm(u, eta, max_edge_ratio=50, CG0H=3, p=4)
            metricTime = time() - startTime
            if iii != Nadapt - 1:
                mesh = adapt(H)
                TadaptTime = time() - startTime
                L2error = errornorm(Expression(testsol),
                                    u,
                                    degree_rise=4,
                                    norm_type='L2')
                printstr = "%5.0f elements, %0.0e L2error, adapt took %0.0f %% of the total time, (%0.0f %% of which was the metric calculation)" \
                 % (mesh.num_cells(),L2error,TadaptTime/(TadaptTime+soltime)*100,metricTime/TadaptTime*100)
                if len(eta_list) == 1:
                    print(printstr)
            else:
                error_list.append(L2error)
                dof_list.append(len(u.vector().array()))
                print(printstr)

    if len(dof_list) > 1:
        dof_list = array(dof_list)
        error_list = array(error_list)
        figure()
        loglog(dof_list, error_list, '.b-', linewidth=2, markersize=16)
        xlabel('Degree of freedoms')
        ylabel('L2 error')


#    # PLOT MESH
#    figure()
    coords = mesh.coordinates().transpose()
    #    triplot(coords[0],coords[1],mesh.cells(),linewidth=0.1)
    #    #savefig('mesh.png',dpi=300) #savefig('mesh.eps');

    figure()  #solution
    testf = interpolate(Expression(testsol), FunctionSpace(mesh, 'CG', 1))
    vtx2dof = vertex_to_dof_map(FunctionSpace(mesh, "CG", 1))
    zz = testf.vector().array()[vtx2dof]
    hh = tricontourf(coords[0], coords[1], mesh.cells(), zz, 100)
    colorbar(hh)
    #savefig('solution.png',dpi=300) #savefig('solution.eps');

    figure()  #analytical solution
    testfe = interpolate(u, FunctionSpace(mesh, 'CG', 1))
    zz = testfe.vector().array()[vtx2dof]
    hh = tricontourf(coords[0], coords[1], mesh.cells(), zz, 100)
    colorbar(hh)
    #savefig('analyt.png',dpi=300) #savefig('analyt.eps');

    figure()  #error
    zz -= testf.vector().array()[vtx2dof]
    zz[zz == 1] -= 1e-16
    hh = tricontourf(mesh.coordinates()[:, 0],
                     mesh.coordinates()[:, 1],
                     mesh.cells(),
                     zz,
                     100,
                     cmap=get_cmap('binary'))
    colorbar(hh)

    hold('on')
    triplot(mesh.coordinates()[:, 0],
            mesh.coordinates()[:, 1],
            mesh.cells(),
            color='r',
            linewidth=0.5)
    hold('off')
    axis('equal')
    box('off')
    title('error')
    show()
Beispiel #25
0

x_list = numpy.random.random(7)
y_list = numpy.random.random(7)

p_list = [[39.82822367, -121.02163792], [39.5625, -121.4666],
          [39.6406, -120.6566], [39.5794, -121.0448], [39.5577, -120.6566],
          [39.5577, -121.4666], [39.5794, -121.0448]]

for i in range(len(p_list)):
    x_list[i] = p_list[i][0]
    y_list[i] = p_list[i][1]

tri = scipy.spatial.Delaunay(
    numpy.array([[x, y] for x, y in zip(x_list, y_list)]))

for j in range(len(p_list)):
    pylab.subplot(2, len(p_list) - 3, j + 1)
    pindex = j

    neighbor_indices = find_neighbors(pindex, tri)
    print(neighbor_indices)
    for i in range(len(x_list)):
        pylab.triplot(x_list, y_list, tri.simplices.copy())

    pylab.plot(x_list, y_list, 'b.')
    pylab.plot(x_list[pindex], y_list[pindex], 'dg')
    pylab.plot([x_list[i] for i in neighbor_indices],
               [y_list[i] for i in neighbor_indices], 'ro')

pylab.show()
def maximal_example(eta_list = array([0.001]), Nadapt=5, timet=1., period=2*pi):
    ### CONSTANTS

    ### SETUP SOLUTION
    #testsol = '0.1*sin(50*x+2*pi*t/T)+atan(-0.1/(2*x - sin(5*y+2*pi*t/T)))';
    sx = Symbol('sx'); sy = Symbol('sy'); sT = Symbol('sT'); st = Symbol('st');  spi = Symbol('spi')
    testsol = 0.1*pysin(50*sx+2*spi*st/sT)+pyatan(-0.1,2*sx - pysin(5*sy+2*spi*st/sT))
    ddtestsol = str(diff(testsol,sx,sx)+diff(testsol,sy,sy)).replace('sx','x[0]').replace('sy','x[1]').replace('spi','pi')
    
    # replacing **P with pow(,P)
    ddtestsol = ddtestsol.replace("(2*x[0] - sin(5*x[1] + 2*pi*st/sT))**2","pow(2*x[0] - sin(5*x[1] + 2*pi*st/sT),2.)")
    ddtestsol = ddtestsol.replace("cos(5*x[1] + 2*pi*st/sT)**2","pow(cos(5*x[1] + 2*pi*st/sT),2.)")
    ddtestsol = ddtestsol.replace("(pow(2*x[0] - sin(5*x[1] + 2*pi*st/sT),2.) + 0.01)**2","pow((pow(2*x[0] - sin(5*x[1] + 2*pi*st/sT),2.) + 0.01),2.)")
    ddtestsol = ddtestsol.replace("(1 + 0.01/pow(2*x[0] - sin(5*x[1] + 2*pi*st/sT),2.))**2","pow(1 + 0.01/pow(2*x[0] - sin(5*x[1] + 2*pi*st/sT),2.),2.)")
    ddtestsol = ddtestsol.replace("(2*x[0] - sin(5*x[1] + 2*pi*st/sT))**5","pow(2*x[0] - sin(5*x[1] + 2*pi*st/sT),5.)")
    #insert values
    ddtestsol = ddtestsol.replace('sT',str(period)).replace('st',str(timet))
    testsol = str(testsol).replace('sx','x[0]').replace('sy','x[1]').replace('spi','pi').replace('sT',str(period)).replace('st',str(timet))
    ddtestsol = "-("+ddtestsol+")"
    
    error_list = []; dof_list = []
    for eta in eta_list:
        meshsz = 40
        ### SETUP MESH
    #   mesh = RectangleMesh(0.4,-0.1,0.6,0.3,1*meshsz,1*meshsz,"left/right") #shock
    #   mesh = RectangleMesh(-0.75,-0.3,-0.3,0.5,1*meshsz,1*meshsz,"left/right") #waves
        mesh = RectangleMesh(-1.5,-0.25,0.5,0.75,1*meshsz,1*meshsz,"left/right") #shock+waves
        
        def boundary(x):
              return near(x[0],mesh.coordinates()[:,0].min()) or near(x[0],mesh.coordinates()[:,0].max()) \
              or near(x[1],mesh.coordinates()[:,1].min()) or near(x[1],mesh.coordinates()[:,1].max())
        # PERFORM ONE ADAPTATION ITERATION
        for iii in range(Nadapt):
         startTime = time()
         V = FunctionSpace(mesh, "CG" ,2); dis = TrialFunction(V); dus = TestFunction(V); u = Function(V)
    #     R = interpolate(Expression(ddtestsol),V)
         a = inner(grad(dis), grad(dus))*dx
         L = Expression(ddtestsol)*dus*dx #
         bc = DirichletBC(V, Expression(testsol), boundary)
         solve(a == L, u, bc)
         soltime = time()-startTime
         
         startTime = time()
         H = metric_pnorm(u, eta, max_edge_ratio=50, CG0H=3, p=4)
         metricTime = time()-startTime
         if iii != Nadapt-1:
          mesh = adapt(H) 
          TadaptTime = time()-startTime
          L2error = errornorm(Expression(testsol), u, degree_rise=4, norm_type='L2')
          printstr = "%5.0f elements, %0.0e L2error, adapt took %0.0f %% of the total time, (%0.0f %% of which was the metric calculation)" \
           % (mesh.num_cells(),L2error,TadaptTime/(TadaptTime+soltime)*100,metricTime/TadaptTime*100)
          if len(eta_list) == 1:
           print(printstr)
         else:
          error_list.append(L2error); dof_list.append(len(u.vector().array()))
          print(printstr)
    
    if len(dof_list) > 1:
        dof_list = array(dof_list); error_list = array(error_list)
        figure()
        loglog(dof_list,error_list,'.b-',linewidth=2,markersize=16); xlabel('Degree of freedoms'); ylabel('L2 error')
#    # PLOT MESH
#    figure()
    coords = mesh.coordinates().transpose()
#    triplot(coords[0],coords[1],mesh.cells(),linewidth=0.1)
#    #savefig('mesh.png',dpi=300) #savefig('mesh.eps'); 
            
    figure() #solution
    testf = interpolate(Expression(testsol),FunctionSpace(mesh,'CG',1))
    vtx2dof = vertex_to_dof_map(FunctionSpace(mesh, "CG" ,1))
    zz = testf.vector().array()[vtx2dof]
    hh=tricontourf(coords[0],coords[1],mesh.cells(),zz,100)
    colorbar(hh)
    #savefig('solution.png',dpi=300) #savefig('solution.eps'); 
    
    figure() #analytical solution
    testfe = interpolate(u,FunctionSpace(mesh,'CG',1))
    zz = testfe.vector().array()[vtx2dof]
    hh=tricontourf(coords[0],coords[1],mesh.cells(),zz,100)
    colorbar(hh)
    #savefig('analyt.png',dpi=300) #savefig('analyt.eps');
    
    figure() #error
    zz -= testf.vector().array()[vtx2dof]; zz[zz==1] -= 1e-16
    hh=tricontourf(mesh.coordinates()[:,0],mesh.coordinates()[:,1],mesh.cells(),zz,100,cmap=get_cmap('binary'))
    colorbar(hh)
    
    hold('on'); triplot(mesh.coordinates()[:,0],mesh.coordinates()[:,1],mesh.cells(),color='r',linewidth=0.5); hold('off')
    axis('equal'); box('off'); title('error')
    show()
def own_concave(points, alpha):
    tri = scipy.spatial.Delaunay(points)
    #################
    pylab.triplot(max_pos[:,0], max_pos[:,1], tri.simplices.copy())
    pylab.plot(max_pos[:,0], max_pos[:,1], 'ro')
    plt.show()
    #################
    index = 0
    for triangle in tri.simplices:
        #print("Warning: hier ist der max_pos index hoechstwahrscheinlich falsch")
        #vertice0=max_pos[triangle[0]]
        #vertice1=max_pos[triangle[1]]
        #vertice2=max_pos[triangle[2]]
        vertice0=points[triangle[0]]
        vertice1=points[triangle[1]]
        vertice2=points[triangle[2]]
        edge0 = np.linalg.norm(vertice0-vertice1)
        edge1 = np.linalg.norm(vertice2-vertice1)
        edge2 = np.linalg.norm(vertice0-vertice2)
        if (edge0 > alpha or edge1 > alpha or edge2 > alpha):
            tri.simplices = np.delete(tri.simplices, index, 0)
        else:
            index += 1
    
    #################
    pylab.triplot(max_pos[:,0], max_pos[:,1], tri.simplices.copy())
    pylab.plot(max_pos[:,0], max_pos[:,1], 'ro')
    plt.show()
    #################
    
    edges = []
    for triangle in tri.simplices:
        edges.append([triangle[0], triangle[1]])
        edges.append([triangle[1], triangle[2]])
        edges.append([triangle[0], triangle[2]])
    edges = np.array(edges)
    """
    #cool but it can be solved diferent
    #sorted for the first element of the edge 2-tuple  [in case (a, b) for a]
    ordered_edges_a = np.sort(edges, axis=0)
    #sorted for the first element of the edge 2-tuple  [in case (a, b) for b]
    edges_b = np.transpose(np.array((edges[:,1], edges[:,0])))
    ordered_edges_b = np.sort(edges_b, axis=0)
    edge_two_times = np.in1d(ordered_edges_a, ordered_edges_b)
    # funktioniert so nicht? erst muss fuer jede kante die rueckkante gefunden
    #werden, erst dann muss nach doppelten kanten gesucht werden
    """
    edges_sort_1 = np.sort(edges, axis=1)
    edges_sort_2 = edges_sort_1[np.argsort(edges_sort_1[:,0])]
    tp = [tuple(row) for row in edges_sort_2]
    print(tp)
    #uniques = np.unique(edges)
    #print (uniques)
    from collections import Counter
    c = Counter(tp)
    c = dict(c)
    #print(c)
    fig, ax = plt.subplots()
    hull_vertices = []
    for key in c:
        if c[key] == 1:
            #print("pairs: " + str(pairs))
            #plt.scatter(points[key[0]][0], points[key[1]][1])
            
            #plt.scatter(points[key[0]][0], points[key[0]][1])
            #plt.scatter(points[key[1]][0], points[key[1]][1])
            ax.plot([points[key[0]][0], points[key[1]][0]], [points[key[0]][1], points[key[1]][1]], linewidth=4)
            hull_vertices.append(points[key[0]])
    ax.scatter(points[:,0], points[:,1])
    plt.show()
    return np.array(hull_vertices)
    """
Beispiel #28
0
from scipy.spatial import Delaunay
import matplotlib.tri as mtri
print((X.shape))
print((X.size))
points = np.zeros((X.size, 2))
points[:, 0] = X.reshape(X.size)
points[:, 1] = Y.reshape(Y.size)
tess = Delaunay(points)
tri = tess.vertices  # or tess.simplices depending on scipy version
triang = mtri.Triangulation(x=points[:, 0], y=points[:, 1], triangles=tri)
#

pl.contourf(X, Y, Xi1)
pl.colorbar()
#pl.scatter(X,Y,marker='-')
pl.triplot(triang, lw=0.5, color='white')
pl.axis('equal')
pl.title("SCALED MESH : chi1 with arbitrary degree and general hex mesh")
pl.show(block=True)

#****************++

# Xi1 = boxspline(X,Y,1)

# from mpl_toolkits.mplot3d import Axes3D
# from matplotlib import cm
# from matplotlib.ticker import LinearLocator, FormatStrFormatter
# import matplotlib.pyplot as plt
# import numpy as np

# fig = plt.figure()
Beispiel #29
0
from scipy.spatial import Delaunay
import matplotlib.tri as mtri
print(X.shape)
print(X.size)
points = np.zeros((X.size, 2))
points[:,0] = X.reshape(X.size)
points[:,1] = Y.reshape(Y.size)
tess = Delaunay(points)
tri = tess.vertices # or tess.simplices depending on scipy version
triang = mtri.Triangulation(x=points[:, 0], y=points[:, 1], triangles=tri)
#

pl.contourf(X, Y, Xi1)
pl.colorbar()
#pl.scatter(X,Y,marker='-')
pl.triplot(triang, lw=0.5, color='white')
pl.axis('equal')
pl.title("SCALED MESH : chi1 with arbitrary degree and general hex mesh")
pl.show(block=True)

#****************++

# Xi1 = boxspline(X,Y,1)



# from mpl_toolkits.mplot3d import Axes3D
# from matplotlib import cm
# from matplotlib.ticker import LinearLocator, FormatStrFormatter
# import matplotlib.pyplot as plt
# import numpy as np
Beispiel #30
0
def adv_convergence(width=2e-2,
                    delta=1e-2,
                    relp=1,
                    Nadapt=10,
                    use_adapt=True,
                    problem=3,
                    outname='',
                    use_reform=False,
                    CGorderL=[2, 3],
                    noplot=False,
                    Lx=3.):
    ### SETUP SOLUTION
    sy = Symbol('sy')
    width_ = Symbol('ww')
    if problem == 3:
        stepfunc = 0.5 + 165. / 104. / width_ * sy - 20. / 13. / width_**3 * sy**3 - 102. / 13. / width_**5 * sy**5 + 240. / 13. / width_**7 * sy**7
    elif problem == 2:
        stepfunc = 0.5 + 15. / 8. / width_ * sy - 5. / width_**3 * sy**3 + 6. / width_**5 * sy**5
    elif problem == 1:
        stepfunc = 0.5 + 1.5 / width_ * sy - 2 / width_**3 * sy**3
    stepfunc = str(stepfunc).replace('sy',
                                     'x[1]').replace('x[1]**2', '(x[1]*x[1])')
    #REPLACE ** with pow
    stepfunc = stepfunc.replace('x[1]**3', 'pow(x[1],3.)')
    stepfunc = stepfunc.replace('x[1]**5', 'pow(x[1],5.)')
    stepfunc = stepfunc.replace('x[1]**7', 'pow(x[1],7.)')
    testsol = '(-ww/2 < x[1] && x[1] < ww/2 ? ' + stepfunc + ' : 0) + (ww/2<x[1] ? 1 : 0)'
    testsol = testsol.replace('ww**2', '(ww*ww)').replace(
        'ww**3',
        'pow(ww,3.)').replace('ww**5',
                              'pow(ww,5.)').replace('ww**7', 'pow(ww,7.)')
    testsol = testsol.replace('ww', str(width))

    dp = Constant(1.)
    fac = Constant(1 + 2. * delta)
    delta = Constant(delta)

    def left(x, on_boundary):
        return x[0] + Lx / 2. < DOLFIN_EPS

    def right(x, on_boundary):
        return x[0] - Lx / 2. > -DOLFIN_EPS

    def top_bottom(x, on_boundary):
        return x[1] - 0.5 > -DOLFIN_EPS or x[1] + 0.5 < DOLFIN_EPS

    class Inletbnd(SubDomain):
        def inside(self, x, on_boundary):
            return x[0] + Lx / 2. < DOLFIN_EPS

    for CGorder in [2]:  #CGorderL:
        dofs = []
        L2errors = []
        for eta in 0.04 * pyexp2(-array(range(9)) * pylog(2) / 2):
            ### SETUP MESH
            meshsz = int(
                round(80 * 0.005 / (eta * (bool(use_adapt) == False) + 0.05 *
                                    (bool(use_adapt) == True))))
            if not bool(use_adapt) and meshsz > 80:
                continue

            mesh = RectangleMesh(-Lx / 2., -0.5, Lx / 2., 0.5, meshsz, meshsz,
                                 "left/right")
            # PERFORM TEN ADAPTATION ITERATIONS
            for iii in range(Nadapt):
                V = VectorFunctionSpace(mesh, "CG", CGorder)
                Q = FunctionSpace(mesh, "CG", CGorder - 1)
                W = V * Q
                (u, p) = TrialFunctions(W)
                (v, q) = TestFunctions(W)
                alpha = Expression(
                    "-0.25<x[0] && x[0]<0.25 && 0. < x[1] ? 1e4 : 0")

                boundaries = FacetFunction("size_t", mesh)
                #outletbnd = Outletbnd()
                inletbnd = Inletbnd()
                boundaries.set_all(0)
                #outletbnd.mark(boundaries, 1)
                inletbnd.mark(boundaries, 1)
                ds = Measure("ds")[boundaries]
                bc0 = DirichletBC(W.sub(0), Constant((0., 0.)), top_bottom)
                bc1 = DirichletBC(W.sub(1), dp, left)
                bc2 = DirichletBC(W.sub(1), Constant(0), right)
                bc3 = DirichletBC(W.sub(0).sub(1), Constant(0.), left)
                bc4 = DirichletBC(W.sub(0).sub(1), Constant(0.), right)
                bcs = [bc0, bc1, bc2, bc3, bc4]

                bndterm = dp * dot(v, Constant((-1., 0.))) * ds(1)

                a = eta * inner(grad(u), grad(
                    v)) * dx - div(v) * p * dx + q * div(u) * dx + alpha * dot(
                        u, v) * dx  #+bndterm
                L = inner(Constant((0., 0.)), v) * dx - bndterm
                U = Function(W)
                solve(a == L, U, bcs)
                u, ps = U.split()

                #SOLVE CONCENTRATION
                mm = mesh_metric2(mesh)
                vdir = u / sqrt(inner(u, u) + DOLFIN_EPS)
                if iii == 0 or use_reform == False:
                    Q2 = FunctionSpace(mesh, 'CG', 2)
                    c = Function(Q2)
                q = TestFunction(Q2)
                p = TrialFunction(Q2)
                newq = (q + dot(vdir, dot(mm, vdir)) * inner(grad(q), vdir)
                        )  #SUPG
                if use_reform:
                    F = newq * (fac / (
                        (1 + exp(-c))**2) * exp(-c)) * inner(grad(c), u) * dx
                    J = derivative(F, c)
                    bc = DirichletBC(
                        Q2,
                        Expression("-log(" + str(float(fac)) + "/(" + testsol +
                                   "+" + str(float(delta)) + ")-1)"), left)
                    #                 bc = DirichletBC(Q, -ln(fac/(Expression(testsol)+delta)-1), left)
                    problem = NonlinearVariationalProblem(F, c, bc, J)
                    solver = NonlinearVariationalSolver(problem)
                    solver.parameters["newton_solver"][
                        "relaxation_parameter"] = relp
                    solver.solve()
                else:
                    a2 = newq * inner(grad(p), u) * dx
                    bc = DirichletBC(Q2, Expression(testsol), left)
                    L2 = Constant(0.) * q * dx
                    solve(a2 == L2, c, bc)

                if (not bool(use_adapt)) or iii == Nadapt - 1:
                    break
                um = project(sqrt(inner(u, u)), FunctionSpace(mesh, 'CG', 2))
                H = metric_pnorm(um,
                                 eta,
                                 max_edge_ratio=1 + 49 * (use_adapt != 2),
                                 p=2)
                H2 = metric_pnorm(c,
                                  eta,
                                  max_edge_ratio=1 + 49 * (use_adapt != 2),
                                  p=2)
                #H3 = metric_pnorm(ps , eta, max_edge_ratio=1+49*(use_adapt!=2), p=2)
                H4 = metric_ellipse(H, H2)
                #H5 = metric_ellipse(H3,H4,mesh)
                mesh = adapt(H4)
                if use_reform:
                    Q2 = FunctionSpace(mesh, 'CG', 2)
                    c = interpolate(c, Q2)

            if use_reform:
                c = project(fac / (1 + exp(-c)) - delta,
                            FunctionSpace(mesh, 'CG', 2))
            L2error = bnderror(c, Expression(testsol), ds)
            dofs.append(len(c.vector().array()) + len(U.vector().array()))
            L2errors.append(L2error)
            #            fid = open("DOFS_L2errors_mesh_c_CG"+str(CGorder)+outname+".mpy",'w')
            #            pickle.dump([dofs[0],L2errors[0],c.vector().array().min(),c.vector().array().max()-1,mesh.cells(),mesh.coordinates(),c.vector().array()],fid)
            #            fid.close();
            log(
                INFO + 1,
                "%1dX ADAPT<->SOLVE complete: DOF=%5d, error=%0.0e, min(c)=%0.0e,max(c)-1=%0.0e"
                % (Nadapt, dofs[len(dofs) - 1], L2error,
                   c.vector().array().min(), c.vector().array().max() - 1))

        # PLOT MESH + solution
        figure()
        testf = interpolate(c, FunctionSpace(mesh, 'CG', 1))
        testfe = interpolate(Expression(testsol), FunctionSpace(mesh, 'CG', 1))
        vtx2dof = vertex_to_dof_map(FunctionSpace(mesh, "CG", 1))
        zz = testf.vector().array()[vtx2dof]
        zz[zz == 1] -= 1e-16
        hh = tricontourf(mesh.coordinates()[:, 0],
                         mesh.coordinates()[:, 1],
                         mesh.cells(),
                         zz,
                         100,
                         cmap=get_cmap('binary'))
        colorbar(hh)
        hold('on')
        triplot(mesh.coordinates()[:, 0],
                mesh.coordinates()[:, 1],
                mesh.cells(),
                color='r',
                linewidth=0.5)
        hold('off')
        axis('equal')
        box('off')
        #        savefig(outname+'final_mesh_CG2.png',dpi=300) #; savefig('outname+final_mesh_CG2.eps',dpi=300)
        #PLOT ERROR
        figure()
        xe = interpolate(Expression("x[0]"),
                         FunctionSpace(mesh, 'CG', 1)).vector().array()
        ye = interpolate(Expression("x[1]"),
                         FunctionSpace(mesh, 'CG', 1)).vector().array()
        I = xe - Lx / 2 > -DOLFIN_EPS
        I2 = ye[I].argsort()
        pyplot(ye[I][I2],
               testf.vector().array()[I][I2] - testfe.vector().array()[I][I2],
               '-b')
        ylabel('error')
        # PLOT L2error graph
        figure()
        pyloglog(dofs, L2errors, '-b.', linewidth=2, markersize=16)
        xlabel('Degree of freedoms')
        ylabel('L2 error')
        # SAVE SOLUTION
        dofs = array(dofs)
        L2errors = array(L2errors)
        fid = open("DOFS_L2errors_CG" + str(CGorder) + outname + ".mpy", 'w')
        pickle.dump([dofs, L2errors], fid)
        fid.close()
#        #show()

#    #LOAD SAVED SOLUTIONS
#    fid = open("DOFS_L2errors_CG2"+outname+".mpy",'r')
#    [dofs,L2errors] = pickle.load(fid)
#    fid.close()
#
# PERFORM FITS ON LAST THREE POINTS
    NfitP = 5
    I = array(range(len(dofs) - NfitP, len(dofs)))
    slope, ints = polyfit(pylog(dofs[I]), pylog(L2errors[I]), 1)
    fid = open("DOFS_L2errors_CG2_fit" + outname + ".mpy", 'w')
    pickle.dump([dofs, L2errors, slope, ints], fid)
    fid.close()
    #PLOT THEM TOGETHER
    if CGorderL != [2]:
        fid = open("DOFS_L2errors_CG3.mpy", 'r')
        [dofs_old, L2errors_old] = pickle.load(fid)
        fid.close()
        slope2, ints2 = polyfit(pylog(dofs_old[I]), pylog(L2errors_old[I]), 1)
        figure()
        pyloglog(dofs,
                 L2errors,
                 '-b.',
                 dofs_old,
                 L2errors_old,
                 '--b.',
                 linewidth=2,
                 markersize=16)
        hold('on')
        pyloglog(dofs,
                 pyexp2(ints) * dofs**slope,
                 '-r',
                 dofs_old,
                 pyexp2(ints2) * dofs_old**slope2,
                 '--r',
                 linewidth=1)
        hold('off')
        xlabel('Degree of freedoms')
        ylabel('L2 error')
        legend([
            'CG2', 'CG3',
            "%0.2f*log(DOFs)" % slope,
            "%0.2f*log(DOFs)" % slope2
        ])  #legend(['new data','old_data'])


#     savefig('comparison.png',dpi=300) #savefig('comparison.eps');
    if not noplot:
        show()
Beispiel #31
0
def minimal_example(width=2e-2, Nadapt=10, eta=0.01):
    ### CONSTANTS
    meshsz = 40
    hd = Constant(width)
    ### SETUP MESH
    mesh = RectangleMesh(Point(-0.5, -0.5), Point(0.5, 0.5), 1 * meshsz,
                         1 * meshsz, "left/right")
    ### DERIVE FORCING TERM
    angle = pi / 8  #rand*pi/2
    sx = Symbol('sx')
    sy = Symbol('sy')
    width_ = Symbol('ww')
    aa = Symbol('aa')
    testsol = pytanh((sx * pycos(aa) + sy * pysin(aa)) / width_)
    ddtestsol = str(diff(testsol, sx, sx) + diff(testsol, sy, sy)).replace(
        'sx', 'x[0]').replace('sy', 'x[1]')
    #replace ** with pow
    ddtestsol = ddtestsol.replace(
        'tanh((x[0]*sin(aa) + x[1]*cos(aa))/ww)**2',
        'pow(tanh((x[0]*sin(aa) + x[1]*cos(aa))/ww),2.)')
    ddtestsol = ddtestsol.replace('cos(aa)**2', 'pow(cos(aa),2.)').replace(
        'sin(aa)**2', 'pow(sin(aa),2.)').replace('ww**2', '(ww*ww)')
    #insert vaulues
    ddtestsol = ddtestsol.replace('aa', str(angle)).replace('ww', str(width))
    testsol = str(testsol).replace('sx', 'x[0]').replace('sy', 'x[1]').replace(
        'aa', str(angle)).replace('ww', str(width))
    ddtestsol = "-(" + ddtestsol + ")"

    def boundary(x):
        return x[0]-mesh.coordinates()[:,0].min() < DOLFIN_EPS or mesh.coordinates()[:,0].max()-x[0] < DOLFIN_EPS \
        or mesh.coordinates()[:,1].min()+0.5 < DOLFIN_EPS or mesh.coordinates()[:,1].max()-x[1] < DOLFIN_EPS

    # PERFORM TEN ADAPTATION ITERATIONS
    for iii in range(Nadapt):
        V = FunctionSpace(mesh, "CG", 2)
        dis = TrialFunction(V)
        dus = TestFunction(V)
        u = Function(V)
        a = inner(grad(dis), grad(dus)) * dx
        L = Expression(ddtestsol) * dus * dx
        bc = DirichletBC(V, Expression(testsol), boundary)
        solve(a == L, u, bc)
        startTime = time()
        H = metric_pnorm(u, eta, max_edge_length=3., max_edge_ratio=None)
        H = logproject(H)
        if iii != Nadapt - 1:
            mesh = adapt(H)
            L2error = errornorm(Expression(testsol),
                                u,
                                degree_rise=4,
                                norm_type='L2')
            log(
                INFO + 1,
                "total (adapt+metric) time was %0.1fs, L2error=%0.0e, nodes: %0.0f"
                % (time() - startTime, L2error, mesh.num_vertices()))

    #    # PLOT MESH


#    figure()
    coords = mesh.coordinates().transpose()
    #    triplot(coords[0],coords[1],mesh.cells(),linewidth=0.1)
    #    #savefig('mesh.png',dpi=300) #savefig('mesh.eps');

    figure()  #solution
    testf = interpolate(Expression(testsol), FunctionSpace(mesh, 'CG', 1))
    vtx2dof = vertex_to_dof_map(FunctionSpace(mesh, "CG", 1))
    zz = testf.vector().array()[vtx2dof]
    hh = tricontourf(coords[0], coords[1], mesh.cells(), zz, 100)
    colorbar(hh)
    #    savefig('solution.png',dpi=300) #savefig('solution.eps');

    figure()  #analytical solution
    testfe = interpolate(u, FunctionSpace(mesh, 'CG', 1))
    zz = testfe.vector().array()[vtx2dof]
    hh = tricontourf(coords[0], coords[1], mesh.cells(), zz, 100)
    colorbar(hh)
    #savefig('analyt.png',dpi=300) #savefig('analyt.eps');

    figure()  #error
    zz -= testf.vector().array()[vtx2dof]
    zz[zz == 1] -= 1e-16
    hh = tricontourf(mesh.coordinates()[:, 0],
                     mesh.coordinates()[:, 1],
                     mesh.cells(),
                     zz,
                     100,
                     cmap=get_cmap('binary'))
    colorbar(hh)

    hold('on')
    triplot(mesh.coordinates()[:, 0],
            mesh.coordinates()[:, 1],
            mesh.cells(),
            color='r',
            linewidth=0.5)
    hold('off')
    axis('equal')
    box('off')
    title('error')
    show()
def adv_convergence(width=2e-2, delta=1e-2, relp=1, Nadapt=10, use_adapt=True, problem=3, outname='', use_reform=False, CGorderL = [2, 3], noplot=False, Lx=3.):
    ### SETUP SOLUTION
    sy = Symbol('sy'); width_ = Symbol('ww')
    if   problem == 3:
        stepfunc = 0.5+165./104./width_*sy-20./13./width_**3*sy**3-102./13./width_**5*sy**5+240./13./width_**7*sy**7
    elif problem == 2:
        stepfunc = 0.5+15./8./width_*sy-5./width_**3*sy**3+6./width_**5*sy**5 
    elif problem == 1:
        stepfunc = 0.5+1.5/width_*sy-2/width_**3*sy**3
    stepfunc = str(stepfunc).replace('sy','x[1]').replace('x[1]**2','(x[1]*x[1])')
    #REPLACE ** with pow
    stepfunc   = stepfunc.replace('x[1]**3','pow(x[1],3.)')
    stepfunc   = stepfunc.replace('x[1]**5','pow(x[1],5.)')
    stepfunc   = stepfunc.replace('x[1]**7','pow(x[1],7.)')
    testsol    = '(-ww/2 < x[1] && x[1] < ww/2 ? ' + stepfunc   +' : 0) + (ww/2<x[1] ? 1 : 0)'
    testsol = testsol.replace('ww**2','(ww*ww)').replace('ww**3','pow(ww,3.)').replace('ww**5','pow(ww,5.)').replace('ww**7','pow(ww,7.)')
    testsol = testsol.replace('ww',str(width))
        
    dp = Constant(1.)
    fac = Constant(1+2.*delta)
    delta = Constant(delta)
    
    def left(x, on_boundary): 
        return x[0] + Lx/2. < DOLFIN_EPS
    def right(x, on_boundary): 
        return x[0] - Lx/2. > -DOLFIN_EPS
    def top_bottom(x, on_boundary):
        return x[1] - 0.5 > -DOLFIN_EPS or x[1] + 0.5 < DOLFIN_EPS
    class Inletbnd(SubDomain):
        def inside(self, x, on_boundary):
            return x[0] + Lx/2. < DOLFIN_EPS
    for CGorder in [2]: #CGorderL:
        dofs = []
        L2errors = []
        for eta in 0.04*pyexp2(-array(range(9))*pylog(2)/2):
            ### SETUP MESH
            meshsz = int(round(80*0.005/(eta*(bool(use_adapt)==False)+0.05*(bool(use_adapt)==True))))
            if not bool(use_adapt) and meshsz > 80:
                continue
            
            mesh = RectangleMesh(-Lx/2.,-0.5,Lx/2.,0.5,meshsz,meshsz,"left/right")
            # PERFORM TEN ADAPTATION ITERATIONS
            for iii in range(Nadapt):
             V = VectorFunctionSpace(mesh, "CG", CGorder); Q = FunctionSpace(mesh, "CG", CGorder-1)
             W = V*Q
             (u, p) = TrialFunctions(W)
             (v, q) = TestFunctions(W)
             alpha = Expression("-0.25<x[0] && x[0]<0.25 && 0. < x[1] ? 1e4 : 0")
    
             boundaries = FacetFunction("size_t",mesh)                         
             #outletbnd = Outletbnd()
             inletbnd = Inletbnd()
             boundaries.set_all(0)
             #outletbnd.mark(boundaries, 1)
             inletbnd.mark(boundaries, 1)
             ds = Measure("ds")[boundaries]
             bc0 = DirichletBC(W.sub(0), Constant((0., 0.)), top_bottom)
             bc1 = DirichletBC(W.sub(1), dp         ,  left)
             bc2 = DirichletBC(W.sub(1), Constant(0), right)
             bc3 = DirichletBC(W.sub(0).sub(1), Constant(0.), left)
             bc4 = DirichletBC(W.sub(0).sub(1), Constant(0.), right)
             bcs = [bc0,bc1,bc2,bc3,bc4]
             
             bndterm = dp*dot(v,Constant((-1.,0.)))*ds(1)
             
             a = eta*inner(grad(u), grad(v))*dx - div(v)*p*dx + q*div(u)*dx+alpha*dot(u,v)*dx#+bndterm
             L = inner(Constant((0.,0.)), v)*dx -bndterm
             U = Function(W)
             solve(a == L, U,  bcs)
             u, ps = U.split()
             
             #SOLVE CONCENTRATION
             mm = mesh_metric2(mesh)
             vdir = u/sqrt(inner(u,u)+DOLFIN_EPS)             
             if iii == 0 or use_reform == False:
                 Q2 = FunctionSpace(mesh,'CG',2); c = Function(Q2)
             q = TestFunction(Q2); p = TrialFunction(Q2)
             newq = (q+dot(vdir,dot(mm,vdir))*inner(grad(q),vdir)) #SUPG
             if use_reform:
                 F = newq*(fac/((1+exp(-c))**2)*exp(-c))*inner(grad(c),u)*dx
                 J = derivative(F,c)
                 bc = DirichletBC(Q2, Expression("-log("+str(float(fac)) +"/("+testsol+"+"+str(float(delta))+")-1)"), left)
    #                 bc = DirichletBC(Q, -ln(fac/(Expression(testsol)+delta)-1), left)
                 problem = NonlinearVariationalProblem(F,c,bc,J)
                 solver = NonlinearVariationalSolver(problem)
                 solver.parameters["newton_solver"]["relaxation_parameter"] = relp
                 solver.solve()
             else:
                 a2 = newq*inner(grad(p),u)*dx
                 bc = DirichletBC(Q2, Expression(testsol), left)
                 L2 = Constant(0.)*q*dx
                 solve(a2 == L2, c, bc)
    
             if (not bool(use_adapt)) or iii == Nadapt-1:
                 break
             um = project(sqrt(inner(u,u)),FunctionSpace(mesh,'CG',2))
             H  = metric_pnorm(um, eta, max_edge_ratio=1+49*(use_adapt!=2), p=2)
             H2 = metric_pnorm(c, eta, max_edge_ratio=1+49*(use_adapt!=2), p=2)
             #H3 = metric_pnorm(ps , eta, max_edge_ratio=1+49*(use_adapt!=2), p=2)
             H4 = metric_ellipse(H,H2)
             #H5 = metric_ellipse(H3,H4,mesh)
             mesh = adapt(H4)
             if use_reform:
                Q2 = FunctionSpace(mesh,'CG',2)
                c = interpolate(c,Q2)
         
            if use_reform:
             c = project(fac/(1+exp(-c))-delta,FunctionSpace(mesh,'CG',2))
            L2error = bnderror(c,Expression(testsol),ds)
            dofs.append(len(c.vector().array())+len(U.vector().array()))
            L2errors.append(L2error)
#            fid = open("DOFS_L2errors_mesh_c_CG"+str(CGorder)+outname+".mpy",'w')
#            pickle.dump([dofs[0],L2errors[0],c.vector().array().min(),c.vector().array().max()-1,mesh.cells(),mesh.coordinates(),c.vector().array()],fid)
#            fid.close();
            log(INFO+1,"%1dX ADAPT<->SOLVE complete: DOF=%5d, error=%0.0e, min(c)=%0.0e,max(c)-1=%0.0e" % (Nadapt, dofs[len(dofs)-1], L2error,c.vector().array().min(),c.vector().array().max()-1))
        
        # PLOT MESH + solution
        figure()
        testf  = interpolate(c                  ,FunctionSpace(mesh,'CG',1))
        testfe = interpolate(Expression(testsol),FunctionSpace(mesh,'CG',1))
        vtx2dof = vertex_to_dof_map(FunctionSpace(mesh, "CG" ,1))
        zz = testf.vector().array()[vtx2dof]; zz[zz==1] -= 1e-16
        hh=tricontourf(mesh.coordinates()[:,0],mesh.coordinates()[:,1],mesh.cells(),zz,100,cmap=get_cmap('binary'))
        colorbar(hh)
        hold('on'); triplot(mesh.coordinates()[:,0],mesh.coordinates()[:,1],mesh.cells(),color='r',linewidth=0.5); hold('off')
        axis('equal'); box('off')
#        savefig(outname+'final_mesh_CG2.png',dpi=300) #; savefig('outname+final_mesh_CG2.eps',dpi=300)
        #PLOT ERROR
        figure()
        xe = interpolate(Expression("x[0]"),FunctionSpace(mesh,'CG',1)).vector().array()
        ye = interpolate(Expression("x[1]"),FunctionSpace(mesh,'CG',1)).vector().array()
        I = xe - Lx/2 > -DOLFIN_EPS; I2 = ye[I].argsort()
        pyplot(ye[I][I2],testf.vector().array()[I][I2]-testfe.vector().array()[I][I2],'-b'); ylabel('error')
        # PLOT L2error graph
        figure()
        pyloglog(dofs,L2errors,'-b.',linewidth=2,markersize=16); xlabel('Degree of freedoms'); ylabel('L2 error')
        # SAVE SOLUTION
        dofs = array(dofs); L2errors = array(L2errors)
        fid = open("DOFS_L2errors_CG"+str(CGorder)+outname+".mpy",'w')
        pickle.dump([dofs,L2errors],fid)
        fid.close();
#        #show()
    
#    #LOAD SAVED SOLUTIONS
#    fid = open("DOFS_L2errors_CG2"+outname+".mpy",'r')
#    [dofs,L2errors] = pickle.load(fid)
#    fid.close()
#    
    # PERFORM FITS ON LAST THREE POINTS
    NfitP = 5
    I = array(range(len(dofs)-NfitP,len(dofs)))
    slope,ints   = polyfit(pylog(dofs[I]), pylog(L2errors[I]), 1) 
    fid = open("DOFS_L2errors_CG2_fit"+outname+".mpy",'w')
    pickle.dump([dofs,L2errors,slope,ints],fid)
    fid.close()
    #PLOT THEM TOGETHER
    if CGorderL != [2]:
     fid = open("DOFS_L2errors_CG3.mpy",'r')
     [dofs_old,L2errors_old] = pickle.load(fid)
     fid.close()
     slope2,ints2 = polyfit(pylog(dofs_old[I]), pylog(L2errors_old[I]), 1) 
     figure()
     pyloglog(dofs,L2errors,'-b.',dofs_old,L2errors_old,'--b.',linewidth=2,markersize=16)
     hold('on'); pyloglog(dofs,pyexp2(ints)*dofs**slope,'-r',dofs_old,pyexp2(ints2)*dofs_old**slope2,'--r',linewidth=1); hold('off')
     xlabel('Degree of freedoms'); ylabel('L2 error')
     legend(['CG2','CG3',"%0.2f*log(DOFs)" % slope, "%0.2f*log(DOFs)" % slope2]) #legend(['new data','old_data'])
#     savefig('comparison.png',dpi=300) #savefig('comparison.eps'); 
    if not noplot:
     show()