फेनीसीएस: उच्च आदेश तत्वों की कल्पना

Question

मैं बस FEniCS के साथ खिलवाड़ शुरू कर दिया है। मैं 3 क्रम तत्वों के साथ पॉइसन को हल कर रहा हूं और परिणामों की कल्पना करना चाहूंगा। हालाँकि, जब मैं प्लॉट (यू) का उपयोग करता हूं, तो विज़ुअलाइज़ेशन परिणामों का एक रैखिक प्रक्षेप होता है। जब मैं वीटीके को आउटपुट करता हूं तो मुझे वही मिलता है। एक अन्य कोड में, जिसके साथ मैं काम कर रहा हूं, मैंने एक वीटीके आउटपुटेटर लिखा है जो उच्च ऑर्डर तत्वों को उखाड़ देगा, ताकि वे वास्तव में पैराव्यू में उच्च क्रम देखें। FEniCS में ऐसा कुछ (या बेहतर) है?

Answer 1

आप समाधान को एक महीन जाली पर प्रक्षेपित कर सकते हैं और फिर उसे प्लॉट कर सकते हैं:

from dolfin import *

coarse_mesh = UnitSquareMesh(2, 2)
fine_mesh = refine(refine(refine(coarse_mesh)))

P2_coarse = FunctionSpace(coarse_mesh, "CG", 2)
P1_fine = FunctionSpace(fine_mesh, "CG", 1)

f = interpolate(Expression("sin(pi*x[0])*sin(pi*x[1])"), P2_coarse)
g = interpolate(f, P1_fine)

plot(f, title="Bad plot")
plot(g, title="Good plot")

interactive()

ध्यान दें कि आप महीन जाली पर प्लॉट में मोटे P2 त्रिकोण की रूपरेखा कैसे देख सकते हैं।

Answer 2

मैं काम करने के लिए अनुकूली परिशोधन पर थोड़ा काम कर रहा हूं (नीचे कोड देखें)। कुल मेष आकार और मेष फ़ंक्शन की कुल भिन्नता के साथ त्रुटि सूचक का स्केलिंग सही नहीं है, लेकिन आप अपनी आवश्यकताओं के अनुसार फिट हो सकते हैं। नीचे की छवियाँ # 4 टेस्टकेस के लिए हैं। कोशिकाओं की संख्या 200 से बढ़कर लगभग 24,000 हो जाती है, जो ऊपर से थोड़ी हो सकती है, लेकिन परिणाम काफी अच्छा है। मेष दर्शाता है कि केवल संबंधित भागों को परिष्कृत किया गया है। आप अभी भी जिन कलाकृतियों को देख सकते हैं, वे वही हैं जो तीसरे क्रम के तत्व खुद को पर्याप्त रूप से सही नहीं दर्शा सकते हैं।

from dolfin import *
from numpy import abs


def compute_error(expr, mesh):
    DG = FunctionSpace(mesh, "DG", 0)
    e = project(expr, DG)
    err = abs(e.vector().array())
    dofmap = DG.dofmap()
    return err, dofmap


def refine_by_bool_array(mesh, to_mark, dofmap):
    cell_markers = CellFunction("bool", mesh)
    cell_markers.set_all(False)
    n = 0
    for cell in cells(mesh):
        index = dofmap.cell_dofs(cell.index())[0]
        if to_mark[index]:
            cell_markers[cell] = True
            n += 1
    mesh = refine(mesh, cell_markers)
    return mesh, n


def adapt_mesh(f, mesh, max_err=0.001, exp=0):
    V = FunctionSpace(mesh, "CG", 1)
    while True:
        fi = interpolate(f, V)
        v = CellVolume(mesh)
        expr = v**exp * abs(f-fi)
        err, dofmap = compute_error(expr, mesh)

        to_mark = (err>max_err)
        mesh, n = refine_by_bool_array(mesh, to_mark, dofmap)
        if not n:
            break

        V = FunctionSpace(mesh, "CG", 1)
    return fi, mesh


def show_testcase(i, p, N, fac, title1="", title2=""):
    funcs = ["sin(60*(x[0]-0.5)*(x[1]-0.5))",
             "sin(10*(x[0]-0.5)*(x[1]-0.5))",
             "sin(10*(x[0]-0.5))*sin(pow(3*(x[1]-0.05),2))"]

    mesh = UnitSquareMesh(N, N)
    U = FunctionSpace(mesh, "CG", p)
    f = interpolate(Expression(funcs[i]), U)

    v0 = (1.0/N) ** 2;
    exp = 1
    #exp = 0
    fac2 = (v0/100)**exp
    max_err = fac * fac2
    #print v0, fac, exp, fac2, max_err
    g, mesh2 = adapt_mesh(f, mesh, max_err=max_err, exp=exp)

    plot(mesh, title=title1 + " (mesh)")
    plot(f, title=title1)
    plot(mesh2, title=title2 + " (mesh)")
    plot(g, title=title2)
    interactive()


if __name__ == "__main__":
    N = 10
    fac = 0.01
    show_testcase(0, 1, 10, fac, "degree 1 - orig", "degree 1 - refined (no change)")
    show_testcase(0, 2, 10, fac, "degree 2 - orig", "degree 2 - refined")
    show_testcase(0, 3, 10, fac, "degree 3 - orig", "degree 3 - refined")
    show_testcase(0, 3, 10, 0.2*fac, "degree 3 - orig", "degree 3 - more refined")
    show_testcase(1, 2, 10, fac, "smooth: degree 2 - orig", "smooth: degree 2 - refined")
    show_testcase(1, 3, 10, fac, "smooth: degree 3 - orig", "smooth: degree 3 - refined")
    show_testcase(2, 2, 10, fac, "bumps: degree 2 - orig", "bumps: degree 2 - refined")
    show_testcase(2, 3, 10, fac, "bumps: degree 3 - orig", "bumps: degree 3 - refined")