Beispiel #1
0
def FluidNonLinearSetup(Pressure,mu, u_k):
    MO.PrintStr("Preconditioning Fluid linear setup",3,"=")
    # parameters['linear_algebra_backend'] = 'uBLAS'
    p = TrialFunction(Pressure)
    q = TestFunction(Pressure)
    mesh = Pressure.mesh()
    N = FacetNormal(Pressure.mesh())
    h = CellSize(Pressure.mesh())
    h_avg =avg(h)

    alpha = 10.0
    gamma =10.0
    tic()
    if Pressure.__str__().find("CG") == -1:
        Fp = assemble(mu*(jump(q)*jump(p)*dx(mesh)) \
                                + inner(inner(grad(p),u_k),q)*dx(mesh)- (1./2)*inner(u_k,N)*inner(q,p)*ds(mesh) \
                                -(1./2)*(inner(u_k('+'),N('+'))+inner(u_k('-'),N('-')))*avg(inner(q,p))*ds(mesh) \
                                -dot(avg(q),dot(outer(p('+'),N('+'))+outer(p('-'),N('-')),avg(u_k)))*dS(Pressure.mesh()))
    else:
        if mesh.topology().dim() == 2:
            Fp = assemble(mu*inner(grad(q), grad(p))*dx(mesh)+inner((u_k[0]*grad(p)[0]+u_k[1]*grad(p)[1]),q)*dx(mesh) + (1./2)*div(u_k)*inner(p,q)*dx(mesh) + (1./2)*(u_k[0]*N[0]+u_k[1]*N[1])*inner(p,q)*ds(mesh))
        else:
            Fp = assemble(mu*inner(grad(q), grad(p))*dx(mesh)+inner((u_k[0]*grad(p)[0]+u_k[1]*grad(p)[1]+u_k[2]*grad(p)[2]),q)*dx(mesh) + (1./2)*div(u_k)*inner(p,q)*dx(mesh) - (1./2)*(u_k[0]*N[0]+u_k[1]*N[1]+u_k[2]*N[2])*inner(p,q)*ds(mesh))# + (-mu*inner(grad(q),N)*p + inner(u_k, N)*q*p)*ds(2))

    Fp = CP.Assemble(Fp)
    print ("{:40}").format("DG convection-diffusion assemble, time: "), " ==>  ",("{:4f}").format(toc()),  ("{:9}").format("   time: "), ("{:4}").format(time.strftime('%X %x %Z')[0:5])

    tic()
    kspFp= NSprecondSetup.PCDKSPnonlinear(Fp)
    print ("{:40}").format("Non-linear fluid precond, time: "), " ==>  ",("{:4f}").format(toc()),  ("{:9}").format("   time: "), ("{:4}").format(time.strftime('%X %x %Z')[0:5])
    print "\n\n"
    return kspFp, Fp
Beispiel #2
0
def FluidLinearSetup(Pressure,mu):
    MO.PrintStr("Preconditioning Fluid linear setup",3,"=","\n\n")
    parameters['linear_algebra_backend'] = 'uBLAS'
    p = TrialFunction(Pressure)
    q = TestFunction(Pressure)

    N = FacetNormal(Pressure.mesh())
    h = CellSize(Pressure.mesh())
    h_avg =avg(h)

    alpha = 10.0
    gamma =10.0
    tic()
    if Pressure.__str__().find("CG") == -1:
        L = assemble(mu*(inner(grad(q), grad(p))*dx(Pressure.mesh()) \
                                - inner(avg(grad(q)), outer(p('+'),N('+'))+outer(p('-'),N('-')))*dS(Pressure.mesh()) \
                                - inner(outer(q('+'),N('+'))+outer(q('-'),N('-')), avg(grad(p)))*dS(Pressure.mesh()) \
                                + alpha/h_avg*inner(outer(q('+'),N('+'))+outer(q('-'),N('-')),outer(p('+'),N('+'))+outer(p('-'),N('-')))*dS(Pressure.mesh()) \
                                - inner(outer(q,N), grad(p))*ds(Pressure.mesh()) \
                                - inner(grad(q), outer(p,N))*ds(Pressure.mesh()) \
                                + gamma/h*inner(q,p)*ds(Pressure.mesh())))
    else:
        L = assemble(mu*(inner(grad(q), grad(p))*dx(Pressure.mesh()))) 
    L = PETSc.Mat().createAIJ(size=L.sparray().shape,csr=(L.sparray().indptr, L.sparray().indices, L.sparray().data))
    print ("{:40}").format("DG scalar Laplacian assemble, time: "), " ==>  ",("{:4f}").format(toc()),  ("{:9}").format("   time: "), ("{:4}").format(time.strftime('%X %x %Z')[0:5])
    tic()
    Q = assemble((1./mu)*inner(p,q)*dx)
    Q = PETSc.Mat().createAIJ(size=Q.sparray().shape,csr=(Q.sparray().indptr, Q.sparray().indices, Q.sparray().data))
    print ("{:40}").format("DG scalar mass matrix assemble, time: "), " ==>  ",("{:4f}").format(toc()),  ("{:9}").format("   time: "), ("{:4}").format(time.strftime('%X %x %Z')[0:5])
    tic()
    kspA, ksp = NSprecondSetup.PCDKSPlinear(Q, L)
    print ("{:40}").format("Linear fluid precond setup, time: "), " ==>  ",("{:4f}").format(toc()),  ("{:9}").format("   time: "), ("{:4}").format(time.strftime('%X %x %Z')[0:5])

    return [kspA,ksp], [L,Q]
Beispiel #3
0
def FluidLinearSetup(Pressure, mu, mesh):
    MO.PrintStr("Preconditioning Fluid linear setup", 3, "=", "\n\n")
    # parameters['linear_algebra_backend'] = 'uBLAS'
    q = TrialFunction(Pressure)
    p = TestFunction(Pressure)

    tic()
    L = assemble(mu * inner(grad(q), grad(p)) * dx,
                 form_compiler_parameters=ffc_options)
    L = CP.Assemble(L)
    print("{:40}").format("CG scalar Laplacian assemble, time: "), " ==>  ", (
        "{:4f}").format(toc()), ("{:9}").format("   time: "), ("{:4}").format(
            time.strftime('%X %x %Z')[0:5])

    tic()
    Q = assemble((1. / mu) * inner(p, q) * dx,
                 form_compiler_parameters=ffc_options)
    Q = CP.Assemble(Q)
    print(
        "{:40}").format("DG scalar mass matrix assemble, time: "), " ==>  ", (
            "{:4f}").format(
                toc()), ("{:9}").format("   time: "), ("{:4}").format(
                    time.strftime('%X %x %Z')[0:5])

    tic()
    kspL, kspQ = NSprecondSetup.PCDKSPlinear(L, Q)
    print("{:40}").format("Linear fluid precond setup, time: "), " ==>  ", (
        "{:4f}").format(toc()), ("{:9}").format("   time: "), ("{:4}").format(
            time.strftime('%X %x %Z')[0:5])

    return [kspL, kspQ], [L, Q]
Beispiel #4
0
def FluidLinearSetup(Pressure,mu,mesh, boundaries, domains):
    MO.PrintStr("Preconditioning Fluid linear setup",3,"=","\n\n")
    # parameters['linear_algebra_backend'] = 'uBLAS'
    q = TrialFunction(Pressure)
    p = TestFunction(Pressure)
    dx = Measure('dx', domain=mesh, subdomain_data=domains)
    ds = Measure('ds', domain=mesh, subdomain_data=boundaries)

    N = FacetNormal(Pressure.mesh())
    h = CellSize(Pressure.mesh())
    h_avg =avg(h)

    alpha = 10.0
    gamma =10.0
    tic()
    if Pressure.__str__().find("CG") == -1:
        L = assemble(mu*(jump(q)*jump(p)*dx(Pressure.mesh())))
    else:
        L = assemble(mu*(inner(grad(q), grad(p))*dx(Pressure.mesh())))# +  inner(grad(q),N)*p*ds(2))
    L = CP.Assemble(L)
    print ("{:40}").format("CG scalar Laplacian assemble, time: "), " ==>  ",("{:4f}").format(toc()),  ("{:9}").format("   time: "), ("{:4}").format(time.strftime('%X %x %Z')[0:5])
    tic()
    Q = assemble((1./mu)*inner(p,q)*dx)
    Q = CP.Assemble(Q)
    print ("{:40}").format("DG scalar mass matrix assemble, time: "), " ==>  ",("{:4f}").format(toc()),  ("{:9}").format("   time: "), ("{:4}").format(time.strftime('%X %x %Z')[0:5])
    tic()
    kspA, ksp = NSprecondSetup.PCDKSPlinear(Q, L)
    print ("{:40}").format("Linear fluid precond setup, time: "), " ==>  ",("{:4f}").format(toc()),  ("{:9}").format("   time: "), ("{:4}").format(time.strftime('%X %x %Z')[0:5])

    return [kspA,ksp], [L,Q]
Beispiel #5
0
def FluidNonLinearSetup(Pressure, mu, u_k):
    MO.PrintStr("Preconditioning Fluid linear setup", 3, "=")
    parameters['linear_algebra_backend'] = 'uBLAS'
    p = TrialFunction(Pressure)
    q = TestFunction(Pressure)
    mesh = Pressure.mesh()
    N = FacetNormal(Pressure.mesh())
    h = CellSize(Pressure.mesh())
    h_avg = avg(h)

    alpha = 10.0
    gamma = 10.0

    tic()
    Fp = assemble(mu*(inner(grad(q), grad(p))*dx(mesh) \
                            - inner(avg(grad(q)), outer(p('+'),N('+'))+outer(p('-'),N('-')))*dS (Pressure.mesh())\
                            - inner(outer(q('+'),N('+'))+outer(q('-'),N('-')), avg(grad(p)))*dS (Pressure.mesh())\
                            +
                            alpha/h_avg*inner(outer(q('+'),N('+'))+outer(q('-'),N('-')),outer(p('+'),N('+'))+outer(p('-'),N('-')))*dS(Pressure.mesh()) \
                            - inner(outer(q,N), grad(p))*ds(mesh) \
                            - inner(grad(q), outer(p,N))*ds(mesh) \
                            + gamma/h*inner(q,p)*ds(mesh)) \
                            + inner(inner(grad(p),u_k),q)*dx(mesh)- (1/2)*inner(u_k,N)*inner(q,p)*ds(mesh) \
                            -(1/2)*(inner(u_k('+'),N('+'))+inner(u_k('-'),N('-')))*avg(inner(q,p))*ds(mesh) \
                            -dot(avg(q),dot(outer(p('+'),N('+'))+outer(p('-'),N('-')),avg(u_k)))*dS(Pressure.mesh()))
    Fp = PETSc.Mat().createAIJ(size=Fp.sparray().shape,
                               csr=(Fp.sparray().indptr, Fp.sparray().indices,
                                    Fp.sparray().data))
    print("{:40}"
          ).format("DG convection-diffusion assemble, time: "), " ==>  ", (
              "{:4f}").format(
                  toc()), ("{:9}").format("   time: "), ("{:4}").format(
                      time.strftime('%X %x %Z')[0:5])

    tic()
    kspFp = NSprecondSetup.PCDKSPnonlinear(Fp)
    print("{:40}").format("Non-linear fluid precond, time: "), " ==>  ", (
        "{:4f}").format(toc()), ("{:9}").format("   time: "), ("{:4}").format(
            time.strftime('%X %x %Z')[0:5])
    print "\n\n"
    return kspFp, Fp
Beispiel #6
0
def foo():
    m = 4

    errL2u = np.zeros((m - 1, 1))
    errH1u = np.zeros((m - 1, 1))
    errL2p = np.zeros((m - 1, 1))
    errL2b = np.zeros((m - 1, 1))
    errCurlb = np.zeros((m - 1, 1))
    errL2r = np.zeros((m - 1, 1))
    errH1r = np.zeros((m - 1, 1))

    l2uorder = np.zeros((m - 1, 1))
    H1uorder = np.zeros((m - 1, 1))
    l2porder = np.zeros((m - 1, 1))
    l2border = np.zeros((m - 1, 1))
    Curlborder = np.zeros((m - 1, 1))
    l2rorder = np.zeros((m - 1, 1))
    H1rorder = np.zeros((m - 1, 1))

    NN = np.zeros((m - 1, 1))
    DoF = np.zeros((m - 1, 1))
    Velocitydim = np.zeros((m - 1, 1))
    Magneticdim = np.zeros((m - 1, 1))
    Pressuredim = np.zeros((m - 1, 1))
    Lagrangedim = np.zeros((m - 1, 1))
    Wdim = np.zeros((m - 1, 1))
    iterations = np.zeros((m - 1, 1))
    SolTime = np.zeros((m - 1, 1))
    udiv = np.zeros((m - 1, 1))
    MU = np.zeros((m - 1, 1))
    level = np.zeros((m - 1, 1))
    NSave = np.zeros((m - 1, 1))
    Mave = np.zeros((m - 1, 1))
    TotalTime = np.zeros((m - 1, 1))

    nn = 2

    dim = 2
    ShowResultPlots = 'yes'
    split = 'Linear'

    MU[0] = 1e0
    for xx in xrange(1, m):
        print xx
        level[xx - 1] = xx + 0
        nn = 2**(level[xx - 1])

        # Create mesh and define function space
        nn = int(nn)
        NN[xx - 1] = nn / 2
        # parameters["form_compiler"]["quadrature_degree"] = 6
        # parameters = CP.ParameterSetup()
        mesh = UnitSquareMesh(nn, nn)

        order = 2
        parameters['reorder_dofs_serial'] = False
        Velocity = VectorFunctionSpace(mesh, "CG", order)
        Pressure = FunctionSpace(mesh, "CG", order - 1)
        Magnetic = FunctionSpace(mesh, "N1curl", order - 1)
        Lagrange = FunctionSpace(mesh, "CG", order - 1)
        W = MixedFunctionSpace([Velocity, Pressure, Magnetic, Lagrange])
        # W = Velocity*Pressure*Magnetic*Lagrange
        Velocitydim[xx - 1] = Velocity.dim()
        Pressuredim[xx - 1] = Pressure.dim()
        Magneticdim[xx - 1] = Magnetic.dim()
        Lagrangedim[xx - 1] = Lagrange.dim()
        Wdim[xx - 1] = W.dim()
        print "\n\nW:  ", Wdim[xx - 1], "Velocity:  ", Velocitydim[
            xx -
            1], "Pressure:  ", Pressuredim[xx - 1], "Magnetic:  ", Magneticdim[
                xx - 1], "Lagrange:  ", Lagrangedim[xx - 1], "\n\n"
        dim = [Velocity.dim(), Pressure.dim(), Magnetic.dim(), Lagrange.dim()]

        def boundary(x, on_boundary):
            return on_boundary

        u0, p0, b0, r0, Laplacian, Advection, gradPres, CurlCurl, gradR, NS_Couple, M_Couple = ExactSol.MHD2D(
            4, 1, mesh)

        bcu = DirichletBC(Velocity, u0, boundary)
        bcb = DirichletBC(Magnetic, b0, boundary)
        bcr = DirichletBC(Lagrange, r0, boundary)

        # bc = [u0,p0,b0,r0]
        bcs = [bcu, bcb, bcr]
        FSpaces = [Velocity, Pressure, Magnetic, Lagrange]

        (u, b, p, r) = TrialFunctions(W)
        (v, c, q, s) = TestFunctions(W)
        kappa = 10.0
        Mu_m = 10.0
        MU = 1.0 / 1
        IterType = 'Full'
        Split = "No"
        Saddle = "No"
        Stokes = "No"
        SetupType = 'python-class'
        F_NS = -MU * Laplacian + Advection + gradPres - kappa * NS_Couple
        if kappa == 0:
            F_M = Mu_m * CurlCurl + gradR - kappa * M_Couple
        else:
            F_M = Mu_m * kappa * CurlCurl + gradR - kappa * M_Couple
        params = [kappa, Mu_m, MU]

        MO.PrintStr("Seting up initial guess matricies", 2, "=", "\n\n", "\n")
        BCtime = time.time()
        BC = MHDsetup.BoundaryIndices(mesh)
        MO.StrTimePrint("BC index function, time: ", time.time() - BCtime)
        Hiptmairtol = 1e-6
        HiptmairMatrices = PrecondSetup.MagneticSetup(Magnetic, Lagrange, b0,
                                                      r0, Hiptmairtol, params)

        MO.PrintStr("Setting up MHD initial guess", 5, "+", "\n\n", "\n\n")
        u_k, p_k, b_k, r_k = common.InitialGuess(FSpaces, [u0, p0, b0, r0],
                                                 [F_NS, F_M],
                                                 params,
                                                 HiptmairMatrices,
                                                 1e-10,
                                                 Neumann=Expression(
                                                     ("0", "0")),
                                                 options="New")
        b_t = TrialFunction(Velocity)
        c_t = TestFunction(Velocity)

        ones = Function(Pressure)
        ones.vector()[:] = (0 * ones.vector().array() + 1)
        # pConst = - assemble(p_k*dx)/assemble(ones*dx)
        p_k.vector()[:] += -assemble(p_k * dx) / assemble(ones * dx)
        x = Iter.u_prev(u_k, p_k, b_k, r_k)

        KSPlinearfluids, MatrixLinearFluids = PrecondSetup.FluidLinearSetup(
            Pressure, MU)
        kspFp, Fp = PrecondSetup.FluidNonLinearSetup(Pressure, MU, u_k)
        #plot(b_k)

        ns, maxwell, CoupleTerm, Lmaxwell, Lns = forms.MHD2D(
            mesh, W, F_M, F_NS, u_k, b_k, params, IterType, "CG", Saddle,
            Stokes)
        RHSform = forms.PicardRHS(mesh, W, u_k, p_k, b_k, r_k, params, "CG",
                                  Saddle, Stokes)

        bcu = DirichletBC(W.sub(0), Expression(("0.0", "0.0")), boundary)
        bcb = DirichletBC(W.sub(2), Expression(("0.0", "0.0")), boundary)
        bcr = DirichletBC(W.sub(3), Expression(("0.0")), boundary)
        bcs = [bcu, bcb, bcr]

        parameters['linear_algebra_backend'] = 'uBLAS'

        eps = 1.0  # error measure ||u-u_k||
        tol = 1.0E-4  # tolerance
        iter = 0  # iteration counter
        maxiter = 10  # max no of iterations allowed
        SolutionTime = 0
        outer = 0
        # parameters['linear_algebra_backend'] = 'uBLAS'

        # FSpaces = [Velocity,Magnetic,Pressure,Lagrange]

        if IterType == "CD":
            MO.PrintStr("Setting up PETSc " + SetupType, 2, "=", "\n", "\n")
            Alin = MHDsetup.Assemble(W, ns, maxwell, CoupleTerm, Lns, Lmaxwell,
                                     RHSform, bcs + BC, "Linear", IterType)
            Fnlin, b = MHDsetup.Assemble(W, ns, maxwell, CoupleTerm, Lns,
                                         Lmaxwell, RHSform, bcs + BC,
                                         "NonLinear", IterType)
            A = Fnlin + Alin
            A, b = MHDsetup.SystemAssemble(FSpaces, A, b, SetupType, IterType)
            u = b.duplicate()

        u_is = PETSc.IS().createGeneral(range(Velocity.dim()))
        NS_is = PETSc.IS().createGeneral(range(Velocity.dim() +
                                               Pressure.dim()))
        M_is = PETSc.IS().createGeneral(
            range(Velocity.dim() + Pressure.dim(), W.dim()))
        OuterTol = 1e-5
        InnerTol = 1e-5
        NSits = 0
        Mits = 0
        TotalStart = time.time()
        SolutionTime = 0
        while eps > tol and iter < maxiter:
            iter += 1
            MO.PrintStr("Iter " + str(iter), 7, "=", "\n\n", "\n\n")
            AssembleTime = time.time()
            if IterType == "CD":
                MO.StrTimePrint("MHD CD RHS assemble, time: ",
                                time.time() - AssembleTime)
                b = MHDsetup.Assemble(W, ns, maxwell, CoupleTerm, Lns,
                                      Lmaxwell, RHSform, bcs + BC, "CD",
                                      IterType)
            else:
                MO.PrintStr("Setting up PETSc " + SetupType, 2, "=", "\n",
                            "\n")
                if Split == "Yes":
                    if iter == 1:
                        Alin = MHDsetup.Assemble(W, ns, maxwell, CoupleTerm,
                                                 Lns, Lmaxwell, RHSform,
                                                 bcs + BC, "Linear", IterType)
                        Fnlin, b = MHDsetup.Assemble(W, ns, maxwell,
                                                     CoupleTerm, Lns, Lmaxwell,
                                                     RHSform, bcs + BC,
                                                     "NonLinear", IterType)
                        A = Fnlin + Alin
                        A, b = MHDsetup.SystemAssemble(FSpaces, A, b,
                                                       SetupType, IterType)
                        u = b.duplicate()
                    else:
                        Fnline, b = MHDsetup.Assemble(W, ns, maxwell,
                                                      CoupleTerm, Lns,
                                                      Lmaxwell, RHSform,
                                                      bcs + BC, "NonLinear",
                                                      IterType)
                        A = Fnlin + Alin
                        A, b = MHDsetup.SystemAssemble(FSpaces, A, b,
                                                       SetupType, IterType)
                else:
                    AA, bb = assemble_system(maxwell + ns + CoupleTerm,
                                             (Lmaxwell + Lns) - RHSform, bcs)
                    A, b = CP.Assemble(AA, bb)
            # if iter == 1:
            MO.StrTimePrint("MHD total assemble, time: ",
                            time.time() - AssembleTime)

            u = b.duplicate()
            kspFp, Fp = PrecondSetup.FluidNonLinearSetup(Pressure, MU, u_k)
            print "Inititial guess norm: ", u.norm(
                PETSc.NormType.NORM_INFINITY)
            #A,Q
            if IterType == 'Full':

                n = FacetNormal(mesh)
                mat = as_matrix([[b_k[1] * b_k[1], -b_k[1] * b_k[0]],
                                 [-b_k[1] * b_k[0], b_k[0] * b_k[0]]])
                a = params[2] * inner(grad(b_t), grad(c_t)) * dx(
                    W.mesh()) + inner((grad(b_t) * u_k), c_t) * dx(W.mesh(
                    )) + (1. / 2) * div(u_k) * inner(c_t, b_t) * dx(
                        W.mesh()) - (1. / 2) * inner(u_k, n) * inner(
                            c_t, b_t) * ds(W.mesh()) + kappa / Mu_m * inner(
                                mat * b_t, c_t) * dx(W.mesh())
                ShiftedMass = assemble(a)
                bcu.apply(ShiftedMass)
                ShiftedMass = CP.Assemble(ShiftedMass)
                kspF = NSprecondSetup.LSCKSPnonlinear(ShiftedMass)
            else:
                F = A.getSubMatrix(u_is, u_is)
                kspF = NSprecondSetup.LSCKSPnonlinear(F)

            aVec, L_M, L_NS, Bt, CoupleT = forms.MHDmatvec(mesh,
                                                           W,
                                                           Laplacian,
                                                           Laplacian,
                                                           u_k,
                                                           b_k,
                                                           u,
                                                           b,
                                                           p,
                                                           r,
                                                           params,
                                                           "Full",
                                                           "CG",
                                                           SaddlePoint="No")
            bcu = DirichletBC(Velocity, u0, boundary)
            PrecondTmult = {'Bt': Bt, 'Ct': CoupleT, 'BC': bcu}
            FS = {
                'velocity': Velocity,
                'pressure': Pressure,
                'magnetic': Magnetic,
                'multiplier': Lagrange
            }
            P = PETSc.Mat().createPython([W.dim(), W.dim()])
            P.setType('python')
            aa = MHDmulti.PetscMatVec(FS, aVec, bcs, PrecondTmult)
            P.setPythonContext(aa)
            P.setUp()
            stime = time.time()
            u, mits, nsits = S.solve(A, P, b, u, params, W, 'Directsss',
                                     IterType, OuterTol, InnerTol,
                                     HiptmairMatrices, Hiptmairtol,
                                     KSPlinearfluids, Fp, kspF)
            Soltime = time.time() - stime
            MO.StrTimePrint("MHD solve, time: ", Soltime)
            Mits += mits
            NSits += nsits
            SolutionTime += Soltime

            u1, p1, b1, r1, eps = Iter.PicardToleranceDecouple(
                u, x, FSpaces, dim, "2", iter)
            p1.vector()[:] += -assemble(p1 * dx) / assemble(ones * dx)
            u_k.assign(u1)
            p_k.assign(p1)
            b_k.assign(b1)
            r_k.assign(r1)
            uOld = np.concatenate((u_k.vector().array(), p_k.vector().array(),
                                   b_k.vector().array(), r_k.vector().array()),
                                  axis=0)
            x = IO.arrayToVec(uOld)

        XX = np.concatenate((u_k.vector().array(), p_k.vector().array(),
                             b_k.vector().array(), r_k.vector().array()),
                            axis=0)
        SolTime[xx - 1] = SolutionTime / iter
        NSave[xx - 1] = (float(NSits) / iter)
        Mave[xx - 1] = (float(Mits) / iter)
        iterations[xx - 1] = iter
        TotalTime[xx - 1] = time.time() - TotalStart
    #     dim = [Velocity.dim(), Pressure.dim(), Magnetic.dim(),Lagrange.dim()]

    #     ExactSolution = [u0,p0,b0,r0]
    #     errL2u[xx-1], errH1u[xx-1], errL2p[xx-1], errL2b[xx-1], errCurlb[xx-1], errL2r[xx-1], errH1r[xx-1] = Iter.Errors(XX,mesh,FSpaces,ExactSolution,order,dim, "DG")

    #     if xx > 1:
    #        l2uorder[xx-1] =  np.abs(np.log2(errL2u[xx-2]/errL2u[xx-1]))
    #        H1uorder[xx-1] =  np.abs(np.log2(errH1u[xx-2]/errH1u[xx-1]))

    #        l2porder[xx-1] =  np.abs(np.log2(errL2p[xx-2]/errL2p[xx-1]))

    #        l2border[xx-1] =  np.abs(np.log2(errL2b[xx-2]/errL2b[xx-1]))
    #        Curlborder[xx-1] =  np.abs(np.log2(errCurlb[xx-2]/errCurlb[xx-1]))

    #        l2rorder[xx-1] =  np.abs(np.log2(errL2r[xx-2]/errL2r[xx-1]))
    #        H1rorder[xx-1] =  np.abs(np.log2(errH1r[xx-2]/errH1r[xx-1]))

    # import pandas as pd

    # LatexTitles = ["l","DoFu","Dofp","V-L2","L2-order","V-H1","H1-order","P-L2","PL2-order"]
    # LatexValues = np.concatenate((level,Velocitydim,Pressuredim,errL2u,l2uorder,errH1u,H1uorder,errL2p,l2porder), axis=1)
    # LatexTable = pd.DataFrame(LatexValues, columns = LatexTitles)
    # pd.set_option('precision',3)
    # LatexTable = MO.PandasFormat(LatexTable,"V-L2","%2.4e")
    # LatexTable = MO.PandasFormat(LatexTable,'V-H1',"%2.4e")
    # LatexTable = MO.PandasFormat(LatexTable,"H1-order","%1.2f")
    # LatexTable = MO.PandasFormat(LatexTable,'L2-order',"%1.2f")
    # LatexTable = MO.PandasFormat(LatexTable,"P-L2","%2.4e")
    # LatexTable = MO.PandasFormat(LatexTable,'PL2-order',"%1.2f")
    # print LatexTable

    # print "\n\n   Magnetic convergence"
    # MagneticTitles = ["l","B DoF","R DoF","B-L2","L2-order","B-Curl","HCurl-order"]
    # MagneticValues = np.concatenate((level,Magneticdim,Lagrangedim,errL2b,l2border,errCurlb,Curlborder),axis=1)
    # MagneticTable= pd.DataFrame(MagneticValues, columns = MagneticTitles)
    # pd.set_option('precision',3)
    # MagneticTable = MO.PandasFormat(MagneticTable,"B-Curl","%2.4e")
    # MagneticTable = MO.PandasFormat(MagneticTable,'B-L2',"%2.4e")
    # MagneticTable = MO.PandasFormat(MagneticTable,"L2-order","%1.2f")
    # MagneticTable = MO.PandasFormat(MagneticTable,'HCurl-order',"%1.2f")
    # print MagneticTable

    # print "\n\n   Lagrange convergence"
    # LagrangeTitles = ["l","B DoF","R DoF","R-L2","L2-order","R-H1","H1-order"]
    # LagrangeValues = np.concatenate((level,Lagrangedim,Lagrangedim,errL2r,l2rorder,errH1r,H1rorder),axis=1)
    # LagrangeTable= pd.DataFrame(LagrangeValues, columns = LagrangeTitles)
    # pd.set_option('precision',3)
    # LagrangeTable = MO.PandasFormat(LagrangeTable,"R-L2","%2.4e")
    # LagrangeTable = MO.PandasFormat(LagrangeTable,'R-H1',"%2.4e")
    # LagrangeTable = MO.PandasFormat(LagrangeTable,"L2-order","%1.2f")
    # LagrangeTable = MO.PandasFormat(LagrangeTable,'H1-order',"%1.2f")
    # print LagrangeTable

    import pandas as pd

    print "\n\n   Iteration table"
    if IterType == "Full":
        IterTitles = [
            "l",
            "DoF",
            "AV solve Time",
            "Total picard time",
            "picard iterations",
            "Av Outer its",
            "Av Inner its",
        ]
    else:
        IterTitles = [
            "l", "DoF", "AV solve Time", "Total picard time",
            "picard iterations", "Av NS iters", "Av M iters"
        ]
    IterValues = np.concatenate(
        (level, Wdim, SolTime, TotalTime, iterations, Mave, NSave), axis=1)
    IterTable = pd.DataFrame(IterValues, columns=IterTitles)
    if IterType == "Full":
        IterTable = MO.PandasFormat(IterTable, 'Av Outer its', "%2.1f")
        IterTable = MO.PandasFormat(IterTable, 'Av Inner its', "%2.1f")
    else:
        IterTable = MO.PandasFormat(IterTable, 'Av NS iters', "%2.1f")
        IterTable = MO.PandasFormat(IterTable, 'Av M iters', "%2.1f")
    print IterTable
    print " \n  Outer Tol:  ", OuterTol, "Inner Tol:   ", InnerTol

    #    tableName = "2d_nu="+str(MU)+"_nu_m="+str(Mu_m)+"_kappa="+str(kappa)+"_l="+str(np.min(level))+"-"+str(np.max(level))+".tex"
    #    IterTable.to_latex(tableName)

    # # # if (ShowResultPlots == 'yes'):

    #    plot(u_k)
    #    plot(interpolate(u0,Velocity))
    #
    #    plot(p_k)
    #
    #    plot(interpolate(p0,Pressure))
    #
    #    plot(b_k)
    #    plot(interpolate(b0,Magnetic))
    #
    #    plot(r_k)
    #    plot(interpolate(r0,Lagrange))
    #
    #    interactive()

    interactive()
Beispiel #7
0
        # print "Inititial guess norm: ",  u.norm(PETSc.NormType.NORM_INFINITY)
        # #A,Q
        n = FacetNormal(mesh)
        b_t = TrialFunction(Velocity)
        c_t = TestFunction(Velocity)
        mat = as_matrix([[b_k[1] * b_k[1], -b_k[1] * b_k[0]],
                         [-b_k[1] * b_k[0], b_k[0] * b_k[0]]])
        aa = params[2] * inner(grad(b_t), grad(c_t)) * dx(W.mesh()) + inner(
            (grad(b_t) * u_k), c_t
        ) * dx(W.mesh()) + (1. / 2) * div(u_k) * inner(c_t, b_t) * dx(
            W.mesh()) - (1. / 2) * inner(u_k, n) * inner(c_t, b_t) * ds(
                W.mesh()) + kappa / Mu_m * inner(mat * b_t, c_t) * dx(W.mesh())
        ShiftedMass = assemble(aa)
        bcu.apply(ShiftedMass)
        ShiftedMass = CP.Assemble(ShiftedMass)
        kspF = NSprecondSetup.LSCKSPnonlinear(ShiftedMass)

        stime = time.time()

        u, mits, nsits = S.solve(A, b, u, params, W, 'Direct', IterType,
                                 OuterTol, InnerTol, HiptmairMatrices,
                                 Hiptmairtol, KSPlinearfluids, Fp, kspF)
        Soltime = time.time() - stime
        MO.StrTimePrint("MHD solve, time: ", Soltime)
        Mits += mits
        NSits += nsits
        SolutionTime += Soltime

        u1, p1, b1, r1, eps = Iter.PicardToleranceDecouple(
            u, x, FSpaces, dim, "2", iter)
        p1.vector()[:] += -assemble(p1 * dx) / assemble(ones * dx)
Beispiel #8
0
def foo():
    m = 6

    errL2u = np.zeros((m - 1, 1))
    errH1u = np.zeros((m - 1, 1))
    errL2p = np.zeros((m - 1, 1))
    errL2b = np.zeros((m - 1, 1))
    errCurlb = np.zeros((m - 1, 1))
    errL2r = np.zeros((m - 1, 1))
    errH1r = np.zeros((m - 1, 1))

    l2uorder = np.zeros((m - 1, 1))
    H1uorder = np.zeros((m - 1, 1))
    l2porder = np.zeros((m - 1, 1))
    l2border = np.zeros((m - 1, 1))
    Curlborder = np.zeros((m - 1, 1))
    l2rorder = np.zeros((m - 1, 1))
    H1rorder = np.zeros((m - 1, 1))

    NN = np.zeros((m - 1, 1))
    DoF = np.zeros((m - 1, 1))
    Velocitydim = np.zeros((m - 1, 1))
    Magneticdim = np.zeros((m - 1, 1))
    Pressuredim = np.zeros((m - 1, 1))
    Lagrangedim = np.zeros((m - 1, 1))
    Wdim = np.zeros((m - 1, 1))
    iterations = np.zeros((m - 1, 1))
    SolTime = np.zeros((m - 1, 1))
    udiv = np.zeros((m - 1, 1))
    MU = np.zeros((m - 1, 1))
    level = np.zeros((m - 1, 1))
    NSave = np.zeros((m - 1, 1))
    Mave = np.zeros((m - 1, 1))
    TotalTime = np.zeros((m - 1, 1))

    nn = 2

    dim = 2
    ShowResultPlots = 'yes'
    split = 'Linear'
    kappa = 0.01
    for yy in xrange(1, 5):
        kappa = kappa * 10
        for xx in xrange(1, m):
            print xx
            level[xx - 1] = xx + 2
            nn = 2**(level[xx - 1])

            # Create mesh and define function space
            nn = int(nn)
            NN[xx - 1] = nn / 2
            # parameters["form_compiler"]["quadrature_degree"] = 6
            # parameters = CP.ParameterSetup()
            mesh = UnitSquareMesh(nn, nn)

            order = 1
            parameters['reorder_dofs_serial'] = False
            Velocity = VectorFunctionSpace(mesh, "CG", order)
            Pressure = FunctionSpace(mesh, "DG", order - 1)
            Magnetic = FunctionSpace(mesh, "N1curl", order)
            Lagrange = FunctionSpace(mesh, "CG", order)
            W = MixedFunctionSpace([Velocity, Pressure, Magnetic, Lagrange])
            # W = Velocity*Pressure*Magnetic*Lagrange
            Velocitydim[xx - 1] = Velocity.dim()
            Pressuredim[xx - 1] = Pressure.dim()
            Magneticdim[xx - 1] = Magnetic.dim()
            Lagrangedim[xx - 1] = Lagrange.dim()
            Wdim[xx - 1] = W.dim()
            print "\n\nW:  ", Wdim[xx - 1], "Velocity:  ", Velocitydim[
                xx - 1], "Pressure:  ", Pressuredim[
                    xx - 1], "Magnetic:  ", Magneticdim[
                        xx - 1], "Lagrange:  ", Lagrangedim[xx - 1], "\n\n"
            dim = [
                Velocity.dim(),
                Pressure.dim(),
                Magnetic.dim(),
                Lagrange.dim()
            ]

            def boundary(x, on_boundary):
                return on_boundary

            u0, p0, b0, r0, Laplacian, Advection, gradPres, CurlCurl, gradR, NS_Couple, M_Couple = ExactSol.MHD2D(
                4, 1)

            bcu = DirichletBC(W.sub(0), u0, boundary)
            bcb = DirichletBC(W.sub(2), b0, boundary)
            bcr = DirichletBC(W.sub(3), r0, boundary)

            # bc = [u0,p0,b0,r0]
            bcs = [bcu, bcb, bcr]
            FSpaces = [Velocity, Pressure, Magnetic, Lagrange]

            (u, b, p, r) = TrialFunctions(W)
            (v, c, q, s) = TestFunctions(W)
            #kappa = 1.0
            MU = 1.0
            Mu_m = 1e1
            IterType = 'Combined'

            F_NS = -MU * Laplacian + Advection + gradPres - kappa * NS_Couple
            if kappa == 0:
                F_M = Mu_m * CurlCurl + gradR - kappa * M_Couple
            else:
                F_M = Mu_m * kappa * CurlCurl + gradR - kappa * M_Couple
            params = [kappa, Mu_m, MU]

            # MO.PrintStr("Preconditioning MHD setup",5,"+","\n\n","\n\n")
            Hiptmairtol = 1e-5
            HiptmairMatrices = PrecondSetup.MagneticSetup(
                Magnetic, Lagrange, b0, r0, Hiptmairtol, params)

            MO.PrintStr("Setting up MHD initial guess", 5, "+", "\n\n", "\n\n")
            u_k, p_k, b_k, r_k = common.InitialGuess(FSpaces, [u0, p0, b0, r0],
                                                     [F_NS, F_M],
                                                     params,
                                                     HiptmairMatrices,
                                                     1e-6,
                                                     Neumann=Expression(
                                                         ("0", "0")),
                                                     options="New",
                                                     FS="DG")
            #plot(p_k, interactive = True)
            b_t = TrialFunction(Velocity)
            c_t = TestFunction(Velocity)
            #print assemble(inner(b,c)*dx).array().shape
            #print mat
            #ShiftedMass = assemble(inner(mat*b,c)*dx)
            #as_vector([inner(b,c)[0]*b_k[0],inner(b,c)[1]*(-b_k[1])])

            ones = Function(Pressure)
            ones.vector()[:] = (0 * ones.vector().array() + 1)
            # pConst = - assemble(p_k*dx)/assemble(ones*dx)
            p_k.vector()[:] += -assemble(p_k * dx) / assemble(ones * dx)
            x = Iter.u_prev(u_k, p_k, b_k, r_k)

            KSPlinearfluids, MatrixLinearFluids = PrecondSetup.FluidLinearSetup(
                Pressure, MU)
            kspFp, Fp = PrecondSetup.FluidNonLinearSetup(Pressure, MU, u_k)
            #plot(b_k)

            ns, maxwell, CoupleTerm, Lmaxwell, Lns = forms.MHD2D(
                mesh, W, F_M, F_NS, u_k, b_k, params, IterType, "DG")
            RHSform = forms.PicardRHS(mesh, W, u_k, p_k, b_k, r_k, params,
                                      "DG")

            bcu = DirichletBC(W.sub(0), Expression(("0.0", "0.0")), boundary)
            bcb = DirichletBC(W.sub(2), Expression(("0.0", "0.0")), boundary)
            bcr = DirichletBC(W.sub(3), Expression(("0.0")), boundary)
            bcs = [bcu, bcb, bcr]

            eps = 1.0  # error measure ||u-u_k||
            tol = 1.0E-4  # tolerance
            iter = 0  # iteration counter
            maxiter = 40  # max no of iterations allowed
            SolutionTime = 0
            outer = 0
            # parameters['linear_algebra_backend'] = 'uBLAS'

            # FSpaces = [Velocity,Magnetic,Pressure,Lagrange]

            if IterType == "CD":
                AA, bb = assemble_system(maxwell + ns,
                                         (Lmaxwell + Lns) - RHSform, bcs)
                A, b = CP.Assemble(AA, bb)
                # u = b.duplicate()
                # P = CP.Assemble(PP)

            u_is = PETSc.IS().createGeneral(range(Velocity.dim()))
            NS_is = PETSc.IS().createGeneral(
                range(Velocity.dim() + Pressure.dim()))
            M_is = PETSc.IS().createGeneral(
                range(Velocity.dim() + Pressure.dim(), W.dim()))
            OuterTol = 1e-5
            InnerTol = 1e-5
            NSits = 0
            Mits = 0
            TotalStart = time.time()
            SolutionTime = 0
            while eps > tol and iter < maxiter:
                iter += 1
                MO.PrintStr("Iter " + str(iter), 7, "=", "\n\n", "\n\n")
                tic()
                if IterType == "CD":
                    bb = assemble((Lmaxwell + Lns) - RHSform)
                    for bc in bcs:
                        bc.apply(bb)
                    FF = AA.sparray()[0:dim[0], 0:dim[0]]
                    A, b = CP.Assemble(AA, bb)
                    # if iter == 1
                    if iter == 1:
                        u = b.duplicate()
                        F = A.getSubMatrix(u_is, u_is)
                        kspF = NSprecondSetup.LSCKSPnonlinear(F)
                else:
                    AA, bb = assemble_system(maxwell + ns + CoupleTerm,
                                             (Lmaxwell + Lns) - RHSform, bcs)
                    A, b = CP.Assemble(AA, bb)
                    # if iter == 1:
                    if iter == 1:
                        u = b.duplicate()
                print("{:40}").format("MHD assemble, time: "), " ==>  ", (
                    "{:4f}").format(
                        toc()), ("{:9}").format("   time: "), ("{:4}").format(
                            time.strftime('%X %x %Z')[0:5])

                kspFp, Fp = PrecondSetup.FluidNonLinearSetup(Pressure, MU, u_k)
                print "Inititial guess norm: ", u.norm()

                #A,Q
                if IterType == 'Combined':

                    n = FacetNormal(mesh)
                    mat = as_matrix([[b_k[1] * b_k[1], -b_k[1] * b_k[0]],
                                     [-b_k[1] * b_k[0], b_k[0] * b_k[0]]])
                    F = A.getSubMatrix(u_is, u_is)
                    a = params[2] * inner(grad(b_t), grad(c_t)) * dx(
                        W.mesh()) + inner((grad(b_t) * u_k), c_t) * dx(
                            W.mesh()) + (1 / 2) * div(u_k) * inner(
                                c_t, b_t) * dx(W.mesh()) - (1 / 2) * inner(
                                    u_k, n) * inner(c_t, b_t) * ds(
                                        W.mesh()) + kappa / Mu_m * inner(
                                            mat * b_t, c_t) * dx(W.mesh())
                    ShiftedMass = assemble(a)
                    bcu.apply(ShiftedMass)

                    kspF = NSprecondSetup.LSCKSPnonlinear(F)
                else:
                    F = A.getSubMatrix(u_is, u_is)
                    kspF = NSprecondSetup.LSCKSPnonlinear(F)

                stime = time.time()
                u, mits, nsits = S.solve(A, b, u, params, W, IterType,
                                         OuterTol, InnerTol, HiptmairMatrices,
                                         Hiptmairtol, KSPlinearfluids, Fp,
                                         kspF)
                Soltime = time.time() - stime
                Mits += mits
                NSits += nsits
                SolutionTime += Soltime

                u1, p1, b1, r1, eps = Iter.PicardToleranceDecouple(
                    u, x, FSpaces, dim, "2", iter)
                p1.vector()[:] += -assemble(p1 * dx) / assemble(ones * dx)
                u_k.assign(u1)
                p_k.assign(p1)
                b_k.assign(b1)
                r_k.assign(r1)
                uOld = np.concatenate(
                    (u_k.vector().array(), p_k.vector().array(),
                     b_k.vector().array(), r_k.vector().array()),
                    axis=0)
                x = IO.arrayToVec(uOld)

            XX = np.concatenate((u_k.vector().array(), p_k.vector().array(),
                                 b_k.vector().array(), r_k.vector().array()),
                                axis=0)
            SolTime[xx - 1] = SolutionTime / iter
            NSave[xx - 1] = (float(NSits) / iter)
            Mave[xx - 1] = (float(Mits) / iter)
            iterations[xx - 1] = iter
            TotalTime[xx - 1] = time.time() - TotalStart
            dim = [
                Velocity.dim(),
                Pressure.dim(),
                Magnetic.dim(),
                Lagrange.dim()
            ]
    #
    #        ExactSolution = [u0,p0,b0,r0]
    #        errL2u[xx-1], errH1u[xx-1], errL2p[xx-1], errL2b[xx-1], errCurlb[xx-1], errL2r[xx-1], errH1r[xx-1] = Iter.Errors(XX,mesh,FSpaces,ExactSolution,order,dim, "DG")
    #
    #        if xx > 1:
    #            l2uorder[xx-1] =  np.abs(np.log2(errL2u[xx-2]/errL2u[xx-1]))
    #            H1uorder[xx-1] =  np.abs(np.log2(errH1u[xx-2]/errH1u[xx-1]))
    #
    #            l2porder[xx-1] =  np.abs(np.log2(errL2p[xx-2]/errL2p[xx-1]))
    #
    #            l2border[xx-1] =  np.abs(np.log2(errL2b[xx-2]/errL2b[xx-1]))
    #            Curlborder[xx-1] =  np.abs(np.log2(errCurlb[xx-2]/errCurlb[xx-1]))
    #
    #            l2rorder[xx-1] =  np.abs(np.log2(errL2r[xx-2]/errL2r[xx-1]))
    #            H1rorder[xx-1] =  np.abs(np.log2(errH1r[xx-2]/errH1r[xx-1]))

        import pandas as pd

        #    LatexTitles = ["l","DoFu","Dofp","V-L2","L2-order","V-H1","H1-order","P-L2","PL2-order"]
        #    LatexValues = np.concatenate((level,Velocitydim,Pressuredim,errL2u,l2uorder,errH1u,H1uorder,errL2p,l2porder), axis=1)
        #    LatexTable = pd.DataFrame(LatexValues, columns = LatexTitles)
        #    pd.set_option('precision',3)
        #    LatexTable = MO.PandasFormat(LatexTable,"V-L2","%2.4e")
        #    LatexTable = MO.PandasFormat(LatexTable,'V-H1',"%2.4e")
        #    LatexTable = MO.PandasFormat(LatexTable,"H1-order","%1.2f")
        #    LatexTable = MO.PandasFormat(LatexTable,'L2-order',"%1.2f")
        #    LatexTable = MO.PandasFormat(LatexTable,"P-L2","%2.4e")
        #    LatexTable = MO.PandasFormat(LatexTable,'PL2-order',"%1.2f")
        #    print LatexTable
        #
        #
        #    print "\n\n   Magnetic convergence"
        #    MagneticTitles = ["l","B DoF","R DoF","B-L2","L2-order","B-Curl","HCurl-order"]
        #    MagneticValues = np.concatenate((level,Magneticdim,Lagrangedim,errL2b,l2border,errCurlb,Curlborder),axis=1)
        #    MagneticTable= pd.DataFrame(MagneticValues, columns = MagneticTitles)
        #    pd.set_option('precision',3)
        #    MagneticTable = MO.PandasFormat(MagneticTable,"B-Curl","%2.4e")
        #    MagneticTable = MO.PandasFormat(MagneticTable,'B-L2',"%2.4e")
        #    MagneticTable = MO.PandasFormat(MagneticTable,"L2-order","%1.2f")
        #    MagneticTable = MO.PandasFormat(MagneticTable,'HCurl-order',"%1.2f")
        #    print MagneticTable
        #
        #
        #
        #
        #    import pandas as pd
        #

        print "\n\n   Iteration table"
        if IterType == "Full":
            IterTitles = [
                "l",
                "DoF",
                "AV solve Time",
                "Total picard time",
                "picard iterations",
                "Av Outer its",
                "Av Inner its",
            ]
        else:
            IterTitles = [
                "l", "DoF", "AV solve Time", "Total picard time",
                "picard iterations", "Av NS iters", "Av M iters"
            ]
        IterValues = np.concatenate(
            (level, Wdim, SolTime, TotalTime, iterations, Mave, NSave), axis=1)
        IterTable = pd.DataFrame(IterValues, columns=IterTitles)
        if IterType == "Full":
            IterTable = MO.PandasFormat(IterTable, 'Av Outer its', "%2.1f")
            IterTable = MO.PandasFormat(IterTable, 'Av Inner its', "%2.1f")
        else:
            IterTable = MO.PandasFormat(IterTable, 'Av NS iters', "%2.1f")
            IterTable = MO.PandasFormat(IterTable, 'Av M iters', "%2.1f")
        print IterTable
        print " \n  Outer Tol:  ", OuterTol, "Inner Tol:   ", InnerTol

        IterTable.to_latex('Tables/IterType=' + IterType + '_n=' + str(m) +
                           '_mu=' + str(MU) + '_kappa=' + str(kappa) +
                           '_mu_m=' + str(Mu_m) + '.tex')

        # # # if (ShowResultPlots == 'yes'):

        #    plot(u_k)
        #    plot(interpolate(u0,Velocity))
        #
        #    plot(p_k)
        #
        #    plot(interpolate(p0,Pressure))
        #
        #    plot(b_k)
        #    plot(interpolate(b0,Magnetic))
        #
        #    plot(r_k)
        #    plot(interpolate(r0,Lagrange))
        #
        #    interactive()

        interactive()
Beispiel #9
0
def foo():
    m = 2


    errL2u =np.zeros((m-1,1))
    errH1u =np.zeros((m-1,1))
    errL2p =np.zeros((m-1,1))
    errL2b =np.zeros((m-1,1))
    errCurlb =np.zeros((m-1,1))
    errL2r =np.zeros((m-1,1))
    errH1r =np.zeros((m-1,1))



    l2uorder =  np.zeros((m-1,1))
    H1uorder =np.zeros((m-1,1))
    l2porder =  np.zeros((m-1,1))
    l2border =  np.zeros((m-1,1))
    Curlborder =np.zeros((m-1,1))
    l2rorder =  np.zeros((m-1,1))
    H1rorder = np.zeros((m-1,1))

    NN = np.zeros((m-1,1))
    DoF = np.zeros((m-1,1))
    Velocitydim = np.zeros((m-1,1))
    Magneticdim = np.zeros((m-1,1))
    Pressuredim = np.zeros((m-1,1))
    Lagrangedim = np.zeros((m-1,1))
    Wdim = np.zeros((m-1,1))
    iterations = np.zeros((m-1,1))
    SolTime = np.zeros((m-1,1))
    udiv = np.zeros((m-1,1))
    MU = np.zeros((m-1,1))
    level = np.zeros((m-1,1))
    NSave = np.zeros((m-1,1))
    Mave = np.zeros((m-1,1))
    TotalTime = np.zeros((m-1,1))
    
    nn = 2

    dim = 2
    ShowResultPlots = 'yes'
    split = 'Linear'

    MU[0]= 1e0
    for xx in xrange(1,m):
        print xx
        level[xx-1] = xx+ 10
        nn = 2**(level[xx-1])



        # Create mesh and define function space
        nn = int(nn)
        NN[xx-1] = nn/2
        # parameters["form_compiler"]["quadrature_degree"] = 6
        # parameters = CP.ParameterSetup()
        mesh = UnitSquareMesh(nn,nn)

        order = 1
        parameters['reorder_dofs_serial'] = False
        Velocity = VectorFunctionSpace(mesh, "CG", order)
        Pressure = FunctionSpace(mesh, "DG", order-1)
        Magnetic = FunctionSpace(mesh, "N1curl", order)
        Lagrange = FunctionSpace(mesh, "CG", order)
        W = MixedFunctionSpace([Velocity,Magnetic, Pressure, Lagrange])
        # W = Velocity*Pressure*Magnetic*Lagrange
        Velocitydim[xx-1] = Velocity.dim()
        Pressuredim[xx-1] = Pressure.dim()
        Magneticdim[xx-1] = Magnetic.dim()
        Lagrangedim[xx-1] = Lagrange.dim()
        Wdim[xx-1] = W.dim()
        print "\n\nW:  ",Wdim[xx-1],"Velocity:  ",Velocitydim[xx-1],"Pressure:  ",Pressuredim[xx-1],"Magnetic:  ",Magneticdim[xx-1],"Lagrange:  ",Lagrangedim[xx-1],"\n\n"
        dim = [Velocity.dim(), Magnetic.dim(), Pressure.dim(), Lagrange.dim()]


        def boundary(x, on_boundary):
            return on_boundary

        u0, p0,b0, r0, Laplacian, Advection, gradPres,CurlCurl, gradR, NS_Couple, M_Couple = ExactSol.MHD2D(4,1)


        bcu = DirichletBC(W.sub(0),u0, boundary)
        bcb = DirichletBC(W.sub(1),b0, boundary)
        bcr = DirichletBC(W.sub(3),r0, boundary)

        # bc = [u0,p0,b0,r0]
        bcs = [bcu,bcb,bcr]
        FSpaces = [Velocity,Pressure,Magnetic,Lagrange]


        (u, b, p, r) = TrialFunctions(W)
        (v, c, q, s) = TestFunctions(W)
        kappa = 1.0
        Mu_m =1e1
        MU = 1.0/1
        IterType = 'Full'

        F_NS = -MU*Laplacian+Advection+gradPres-kappa*NS_Couple
        if kappa == 0:
            F_M = Mu_m*CurlCurl+gradR -kappa*M_Couple
        else:
            F_M = Mu_m*kappa*CurlCurl+gradR -kappa*M_Couple
        params = [kappa,Mu_m,MU]


        # MO.PrintStr("Preconditioning MHD setup",5,"+","\n\n","\n\n")
        HiptmairMatrices = PrecondSetup.MagneticSetup(Magnetic, Lagrange, b0, r0, 1e-5, params)


        MO.PrintStr("Setting up MHD initial guess",5,"+","\n\n","\n\n")
        u_k,p_k,b_k,r_k = common.InitialGuess(FSpaces,[u0,p0,b0,r0],[F_NS,F_M],params,HiptmairMatrices,1e-6,Neumann=Expression(("0","0")),options ="New", FS = "DG")
        #plot(p_k, interactive = True) 
        b_t = TrialFunction(Velocity)
        c_t = TestFunction(Velocity)
        #print assemble(inner(b,c)*dx).array().shape
        #print mat
        #ShiftedMass = assemble(inner(mat*b,c)*dx)
        #as_vector([inner(b,c)[0]*b_k[0],inner(b,c)[1]*(-b_k[1])])

        ones = Function(Pressure)
        ones.vector()[:]=(0*ones.vector().array()+1)
        # pConst = - assemble(p_k*dx)/assemble(ones*dx)
        p_k.vector()[:] += - assemble(p_k*dx)/assemble(ones*dx)
        x = Iter.u_prev(u_k,b_k,p_k,r_k)

        KSPlinearfluids, MatrixLinearFluids = PrecondSetup.FluidLinearSetup(Pressure, MU)
        kspFp, Fp = PrecondSetup.FluidNonLinearSetup(Pressure, MU, u_k)
        #plot(b_k)

        ns,maxwell,CoupleTerm,Lmaxwell,Lns = forms.MHD2D(mesh, W,F_M,F_NS, u_k,b_k,params,IterType,"DG", SaddlePoint = "Yes")
        RHSform = forms.PicardRHS(mesh, W, u_k, p_k, b_k, r_k, params,"DG",SaddlePoint = "Yes")


        bcu = DirichletBC(W.sub(0),Expression(("0.0","0.0")), boundary)
        bcb = DirichletBC(W.sub(1),Expression(("0.0","0.0")), boundary)
        bcr = DirichletBC(W.sub(3),Expression(("0.0")), boundary)
        bcs = [bcu,bcb,bcr]

        eps = 1.0           # error measure ||u-u_k||
        tol = 1.0E-4     # tolerance
        iter = 0            # iteration counter
        maxiter = 40       # max no of iterations allowed
        SolutionTime = 0
        outer = 0
        # parameters['linear_algebra_backend'] = 'uBLAS'

        # FSpaces = [Velocity,Magnetic,Pressure,Lagrange]

        if IterType == "CD":
            AA, bb = assemble_system(maxwell+ns, (Lmaxwell + Lns) - RHSform,  bcs)
            A,b = CP.Assemble(AA,bb)
            # u = b.duplicate()
            # P = CP.Assemble(PP)


        u_is = PETSc.IS().createGeneral(range(Velocity.dim()))
        NS_is = PETSc.IS().createGeneral(range(Velocity.dim()+Pressure.dim()))
        M_is = PETSc.IS().createGeneral(range(Velocity.dim()+Pressure.dim(),W.dim()))
        OuterTol = 1e-5
        InnerTol = 1e-3
        NSits =0
        Mits =0
        TotalStart =time.time()
        SolutionTime = 0
        while eps > tol  and iter < maxiter:
            iter += 1
            MO.PrintStr("Iter "+str(iter),7,"=","\n\n","\n\n")
            tic()
            if IterType == "CD":
                bb = assemble((Lmaxwell + Lns) - RHSform)
                for bc in bcs:
                    bc.apply(bb)
                FF = AA.sparray()[0:dim[0],0:dim[0]]
                A,b = CP.Assemble(AA,bb)
                # if iter == 1
                if iter == 1:
                    u = b.duplicate()
                    F = A.getSubMatrix(u_is,u_is)
                    kspF = NSprecondSetup.LSCKSPnonlinear(F)
            else:
                AA, bb = assemble_system(maxwell+ns+CoupleTerm, (Lmaxwell + Lns) - RHSform,  bcs)
                A,b = CP.Assemble(AA,bb)
                del AA, bb
                n = FacetNormal(mesh)
                mat =  as_matrix([[b_k[1]*b_k[1],-b_k[1]*b_k[0]],[-b_k[1]*b_k[0],b_k[0]*b_k[0]]])
                F = A.getSubMatrix(u_is,u_is)
                a = params[2]*inner(grad(b_t), grad(c_t))*dx(W.mesh()) + inner((grad(b_t)*u_k),c_t)*dx(W.mesh()) +(1/2)*div(u_k)*inner(c_t,b_t)*dx(W.mesh()) - (1/2)*inner(u_k,n)*inner(c_t,b_t)*ds(W.mesh())+kappa/Mu_m*inner(mat*b_t,c_t)*dx(W.mesh())
                ShiftedMass = assemble(a)
                bcu.apply(ShiftedMass)

                #MO.StoreMatrix(AA.sparray()[0:dim[0],0:dim[0]]+ShiftedMass.sparray(),"A")
                kspF = NSprecondSetup.LSCKSPnonlinear(F)
            # if iter == 1:
                if iter == 1:
                    u = b.duplicate()
            print ("{:40}").format("MHD assemble, time: "), " ==>  ",("{:4f}").format(toc()),  ("{:9}").format("   time: "), ("{:4}").format(time.strftime('%X %x %Z')[0:5])

            kspFp, Fp = PrecondSetup.FluidNonLinearSetup(Pressure, MU, u_k)
            print "Inititial guess norm: ", u.norm()
            solver = 'Schur'
            if solver == 'Schur':
                FF = CP.Assemble(ShiftedMass)
                kspF = NSprecondSetup.LSCKSPnonlinear(FF)
                ksp = PETSc.KSP()
                ksp.create(comm=PETSc.COMM_WORLD)
                pc = ksp.getPC()
                ksp.setType('fgmres')
                pc.setType('python')
                pc.setType(PETSc.PC.Type.PYTHON)
                # FSpace = [Velocity,Magnetic,Pressure,Lagrange]
                reshist = {}
                def monitor(ksp, its, fgnorm):
                    reshist[its] = fgnorm
                    print its,"    OUTER:", fgnorm
                # ksp.setMonitor(monitor)
                ksp.max_it = 1000
                FFSS = [Velocity,Magnetic,Pressure,Lagrange]
                pc.setPythonContext(MHDpreconditioner.InnerOuterMAGNETICapprox(FFSS,kspF, KSPlinearfluids[0], KSPlinearfluids[1],Fp, HiptmairMatrices[3], HiptmairMatrices[4], HiptmairMatrices[2], HiptmairMatrices[0], HiptmairMatrices[1], HiptmairMatrices[6],1e-5,FF))
                #OptDB = PETSc.Options()

                # OptDB['pc_factor_mat_solver_package']  = "mumps"
                # OptDB['pc_factor_mat_ordering_type']  = "rcm"
                # ksp.setFromOptions()
                scale = b.norm()
                b = b/scale
                ksp.setOperators(A,A)
                del A
                stime = time.time()
                ksp.solve(b,u)
                Soltime = time.time()- stime
                NSits += ksp.its
                Mits += ksp.its
                # Mits +=dodim
                u = u*scale
                SolutionTime = SolutionTime +Soltime
                MO.PrintStr("Number iterations ="+str(ksp.its),60,"+","\n\n","\n\n")
                MO.PrintStr("Time: "+str(Soltime),60,"+","\n\n","\n\n")
            else:
                kspOuter = PETSc.KSP()
                kspOuter.create(comm=PETSc.COMM_WORLD)
                FFSS = [Velocity,Magnetic,Pressure,Lagrange]
                kspOuter.setType('fgmres')
                kspOuter.setOperators(A,A) 
                pcOuter = kspOuter.getPC()
                pcOuter.setType(PETSc.PC.Type.KSP)              
                
                kspInner = pcOuter.getKSP()
                kspInner.setType('gmres')
                pcInner = kspInner.getPC()

                # FSpace = [Velocity,Magnetic,Pressure,Lagrange]
                reshist = {}
                def monitor(ksp, its, fgnorm):
                    reshist[its] = fgnorm
                    print its,"    OUTER:", fgnorm
                
                kspOuter.setMonitor(monitor)
                kspOuter.max_it = 500
                kspInner.max_it = 100
                kspOuter.setTolerances(OuterTol)
                kspInner.setTolerances(InnerTol)
                
                pcInner.setType('python')
                pcInner.setPythonContext(MHDpreconditioner.InnerOuter(A,FFSS,kspF, KSPlinearfluids[0], KSPlinearfluids[1],Fp, HiptmairMatrices[3], HiptmairMatrices[4], HiptmairMatrices[2], HiptmairMatrices[0], HiptmairMatrices[1], HiptmairMatrices[6],1e-4,F))
                
                # OptDB = PETSc.Options()

                PP = PETSc.Mat().create()
                PP.setSizes([A.size[0], A.size[0]])

                #PP = PETSc.Mat().createPython([A.size[0], A.size[0]])
                PP.setType('python')
                pp = MHDmulti.P(FFSS,A,MatrixLinearFluids[1],MatrixLinearFluids[0],kspFp,HiptmairMatrices[6])
                
                PP.setPythonContext(pp)
                PP.setUp()
                kspInner.setOperators(PP,PP)
                kspInner.setFromOptions()
                scale = b.norm()
                b = b/scale
                del A
                stime = time.time()
                kspOuter.solve(b,u)
                Soltime = time.time()- stime
                NSits += kspOuter.its
                Mits += kspInner.its
                u = u*scale
                SolutionTime = SolutionTime +Soltime
                MO.PrintStr("Number of outer iterations ="+str(kspOuter.its),60,"+","\n\n","\n\n")
                MO.PrintStr("Number of inner iterations ="+str(kspInner.its),60,"+","\n\n","\n\n")
            u1, p1, b1, r1, eps= Iter.PicardToleranceDecouple(u,x,FSpaces,dim,"2",iter, SaddlePoint = "Yes")
            p1.vector()[:] += - assemble(p1*dx)/assemble(ones*dx)
            u_k.assign(u1)
            p_k.assign(p1)
            b_k.assign(b1)
            r_k.assign(r1)
            uOld= np.concatenate((u_k.vector().array(),b_k.vector().array(),p_k.vector().array(),r_k.vector().array()), axis=0)
            x = IO.arrayToVec(uOld)



        XX= np.concatenate((u_k.vector().array(),p_k.vector().array(),b_k.vector().array(),r_k.vector().array()), axis=0)
        SolTime[xx-1] = SolutionTime/iter
        NSave[xx-1] = (float(NSits)/iter)
        Mave[xx-1] = (float(Mits)/iter)
        iterations[xx-1] = iter
        TotalTime[xx-1] = time.time() - TotalStart
        dim = [Velocity.dim(), Pressure.dim(), Magnetic.dim(),Lagrange.dim()]
#
#        ExactSolution = [u0,p0,b0,r0]
#        errL2u[xx-1], errH1u[xx-1], errL2p[xx-1], errL2b[xx-1], errCurlb[xx-1], errL2r[xx-1], errH1r[xx-1] = Iter.Errors(XX,mesh,FSpaces,ExactSolution,order,dim, "DG")
#
#        if xx > 1:
#            l2uorder[xx-1] =  np.abs(np.log2(errL2u[xx-2]/errL2u[xx-1]))
#            H1uorder[xx-1] =  np.abs(np.log2(errH1u[xx-2]/errH1u[xx-1]))
#
#            l2porder[xx-1] =  np.abs(np.log2(errL2p[xx-2]/errL2p[xx-1]))
#
#            l2border[xx-1] =  np.abs(np.log2(errL2b[xx-2]/errL2b[xx-1]))
#            Curlborder[xx-1] =  np.abs(np.log2(errCurlb[xx-2]/errCurlb[xx-1]))
#
#            l2rorder[xx-1] =  np.abs(np.log2(errL2r[xx-2]/errL2r[xx-1]))
#            H1rorder[xx-1] =  np.abs(np.log2(errH1r[xx-2]/errH1r[xx-1]))




    import pandas as pd



#    LatexTitles = ["l","DoFu","Dofp","V-L2","L2-order","V-H1","H1-order","P-L2","PL2-order"]
#    LatexValues = np.concatenate((level,Velocitydim,Pressuredim,errL2u,l2uorder,errH1u,H1uorder,errL2p,l2porder), axis=1)
#    LatexTable = pd.DataFrame(LatexValues, columns = LatexTitles)
#    pd.set_option('precision',3)
#    LatexTable = MO.PandasFormat(LatexTable,"V-L2","%2.4e")
#    LatexTable = MO.PandasFormat(LatexTable,'V-H1',"%2.4e")
#    LatexTable = MO.PandasFormat(LatexTable,"H1-order","%1.2f")
#    LatexTable = MO.PandasFormat(LatexTable,'L2-order',"%1.2f")
#    LatexTable = MO.PandasFormat(LatexTable,"P-L2","%2.4e")
#    LatexTable = MO.PandasFormat(LatexTable,'PL2-order',"%1.2f")
#    print LatexTable
#
#
#    print "\n\n   Magnetic convergence"
#    MagneticTitles = ["l","B DoF","R DoF","B-L2","L2-order","B-Curl","HCurl-order"]
#    MagneticValues = np.concatenate((level,Magneticdim,Lagrangedim,errL2b,l2border,errCurlb,Curlborder),axis=1)
#    MagneticTable= pd.DataFrame(MagneticValues, columns = MagneticTitles)
#    pd.set_option('precision',3)
#    MagneticTable = MO.PandasFormat(MagneticTable,"B-Curl","%2.4e")
#    MagneticTable = MO.PandasFormat(MagneticTable,'B-L2',"%2.4e")
#    MagneticTable = MO.PandasFormat(MagneticTable,"L2-order","%1.2f")
#    MagneticTable = MO.PandasFormat(MagneticTable,'HCurl-order',"%1.2f")
#    print MagneticTable
#
#
#
#
#    import pandas as pd
#



    print "\n\n   Iteration table"
    if IterType == "Full":
        IterTitles = ["l","DoF","AV solve Time","Total picard time","picard iterations","Av Outer its","Av Inner its",]
    else:
        IterTitles = ["l","DoF","AV solve Time","Total picard time","picard iterations","Av NS iters","Av M iters"]
    IterValues = np.concatenate((level,Wdim,SolTime,TotalTime,iterations,NSave,Mave),axis=1)
    IterTable= pd.DataFrame(IterValues, columns = IterTitles)
    if IterType == "Full":
        IterTable = MO.PandasFormat(IterTable,'Av Outer its',"%2.1f")
        IterTable = MO.PandasFormat(IterTable,'Av Inner its',"%2.1f")
    else:
        IterTable = MO.PandasFormat(IterTable,'Av NS iters',"%2.1f")
        IterTable = MO.PandasFormat(IterTable,'Av M iters',"%2.1f")
    print IterTable.to_latex()
    print " \n  Outer Tol:  ",OuterTol, "Inner Tol:   ", InnerTol




    # # # if (ShowResultPlots == 'yes'):

#    plot(u_k)
#    plot(interpolate(u0,Velocity))
#
#    plot(p_k)
#
#    plot(interpolate(p0,Pressure))
#
#    plot(b_k)
#    plot(interpolate(b0,Magnetic))
#
#    plot(r_k)
#    plot(interpolate(r0,Lagrange))
#
#    interactive()

    interactive()
Beispiel #10
0
    TotalStart =time.time()
    SolutionTime = 0
    while eps > tol  and iter < maxiter:
        iter += 1
        MO.PrintStr("Iter "+str(iter),7,"=","\n\n","\n\n")
        tic()
        if IterType == "CD":
            bb = assemble((Lmaxwell + Lns) - RHSform)
            for bc in bcs:
                bc.apply(bb)
            A,b = CP.Assemble(AA,bb)
            # if iter == 1
            if iter == 1:
                u = b.duplicate()
                F = A.getSubMatrix(u_is,u_is)
                kspF = NSprecondSetup.LSCKSPnonlinear(F)
        else:
            AA, bb = assemble_system(maxwell+ns+CoupleTerm, (Lmaxwell + Lns) - RHSform,  bcs)
            A,b = CP.Assemble(AA,bb)
            F = A.getSubMatrix(u_is,u_is)
            kspF = NSprecondSetup.LSCKSPnonlinear(F)
        # if iter == 1:
            if iter == 1:
                u = b.duplicate()
        print ("{:40}").format("MHD assemble, time: "), " ==>  ",("{:4f}").format(toc()),  ("{:9}").format("   time: "), ("{:4}").format(time.strftime('%X %x %Z')[0:5])

        kspFp, Fp = PrecondSetup.FluidNonLinearSetup(Pressure, MU, u_k)

        print "Inititial guess norm: ", u.norm()
        stime = time.time()
        # ksp.solve(b, u)
Beispiel #11
0
        Bt = PP[0:V.dim(), V.dim():W.dim()]
        d = spdiags(1.0 / Xdiag, 0, len(Xdiag), len(Xdiag))
        dBt = (d * Bt).tocsr()

        plt.spy(dBt)
        plt.show()
        BQB = Bt.transpose() * dBt
        dBt = PETSc.Mat().createAIJ(size=dBt.shape,
                                    csr=(dBt.indptr, dBt.indices, dBt.data))
        print dBt.size
        BQB = PETSc.Mat().createAIJ(size=BQB.tocsr().shape,
                                    csr=(BQB.tocsr().indptr,
                                         BQB.tocsr().indices,
                                         BQB.tocsr().data))
        # parameters['linear_algebra_backend'] = 'PETSc'
        kspBQB = NSprecondSetup.Ksp(BQB)
    elif Solver == "PCD":
        N = FacetNormal(mesh)
        h = CellSize(mesh)
        h_avg = avg(h)
        alpha = 10.0
        gamma = 10.0

        (pQ) = TrialFunction(Q)
        (qQ) = TestFunction(Q)
        print MU
        Mass = assemble(inner(pQ, qQ) * dx)
        L = MU * (inner(grad(qQ), grad(pQ)) * dx(mesh))

        #        O = - dot(u_k, n)*pQ('+')*qQ*ds(mesh) - dot(u_k, n)*(pQ('+') - pQ('-'))*qQ('-')*dS(mesh)
        pp = Function(Q)
Beispiel #12
0


        Bt = PP[0:V.dim(),V.dim():W.dim()]
        d = spdiags(1.0/Xdiag, 0, len(Xdiag), len(Xdiag))
        dBt = (d*Bt).tocsr()
        print Bt.transpose()*dBt.todense()

        plt.spy(dBt)
        plt.show()
        BQB = Bt.transpose()*dBt
        dBt = PETSc.Mat().createAIJ(size=dBt.shape,csr=(dBt.indptr, dBt.indices, dBt.data))
        print dBt.size
        BQB = PETSc.Mat().createAIJ(size=BQB.tocsr().shape,csr=(BQB.tocsr().indptr, BQB.tocsr().indices, BQB.tocsr().data))
        # parameters['linear_algebra_backend'] = 'PETSc'
        kspBQB = NSprecondSetup.LSCKSPlinear(BQB)
    elif Solver == "PCD":
        N = FacetNormal(mesh)
        h = CellSize(mesh)
        h_avg =avg(h)
        alpha = 10.0
        gamma =10.0

        (pQ) = TrialFunction(Q)
        (qQ) = TestFunction(Q)
        print MU
        Mass = assemble(inner(pQ,qQ)*dx)
        L = MU*(inner(grad(qQ), grad(pQ))*dx(mesh))

#        O = - dot(u_k, n)*pQ('+')*qQ*ds(mesh) - dot(u_k, n)*(pQ('+') - pQ('-'))*qQ('-')*dS(mesh)
        pp = Function(Q)
Beispiel #13
0
        Mass = assemble(inner(u,v)*dx)
        B = assemble(-div(v)*p*dx)
        bc = DirichletBC(V,Expression(("0.0","0.0")), boundary)
        #bc.apply(Mass)

        Mass = Mass.sparray()
        MassD = Mass.diagonal()
        del Mass
        B = B.sparray()
        
        d = spdiags(1.0/MassD, 0, len(MassD), len(MassD))
        QB = d*B
        L = B.transpose()*QB
        L = PETSc.Mat().createAIJ(size=L.shape,csr=(L.indptr, L.indices, L.data))
        QB = PETSc.Mat().createAIJ(size=QB.shape,csr=(QB.indptr, QB.indices, QB.data))
        KspL = NSsetup.Ksp(L)
    elif Solver == "PCD":
        (pQ) = TrialFunction(Q)
        (qQ) = TestFunction(Q)
        print MU
        Mass = assemble(inner(pQ,qQ)*dx)
        L = assemble(inner(grad(pQ),grad(qQ))*dx)

        fp = MU*inner(grad(qQ), grad(pQ))*dx+inner((u_k[0]*grad(pQ)[0]+u_k[1]*grad(pQ)[1]),qQ)*dx + (1./2)*div(u_k)*inner(pQ,qQ)*dx - (1./2)*(u_k[0]*n[0]+u_k[1]*n[1])*inner(pQ,qQ)*ds
        L = CP.Assemble(L)
        Mass = CP.Assemble(Mass)

    # print L
    SolutionTime = 0
    while eps > tol and iter < maxiter:
        iter += 1