# Diff of /trunk/finley/test/python/run_simplesolve.py

revision 1786 by artak, Thu Aug 14 05:34:25 2008 UTC revision 1787 by artak, Mon Sep 15 01:36:34 2008 UTC
# Line 396  class SimpleSolve_Rectangle_Order1_Singl Line 396  class SimpleSolve_Rectangle_Order1_Singl
396          # -------- test the solution ---------------------------          # -------- test the solution ---------------------------
397          error=Lsup(u-u_ex)/Lsup(u_ex)          error=Lsup(u-u_ex)/Lsup(u_ex)
398          self.failUnless(error<REL_TOL*Lsup(u_ex), "solution error %s is too big."%error)          self.failUnless(error<REL_TOL*Lsup(u_ex), "solution error %s is too big."%error)
399
400    class SimpleSolve_Rectangle_Order2_SinglePDE_Paso_TFQMR_Jacobi(unittest.TestCase):
401         def test_solve(self):
402            domain=Rectangle(NE0,NE1,2,l0=1.,l1=1,optimize=OPTIMIZE)
403            x=Solution(domain).getX()
404            # --- set exact solution ----
405            u_ex=1.+2.*x[0]+3.*x[1]+4.*x[0]**2+5.*x[1]*x[0]+6.*x[1]**2
406            # --- set exact gradient -----------
407            g_ex=Data(0.,(2,),Solution(domain))
408            g_ex[0]=2.+8.*x[0]+5.*x[1]
409            g_ex[1]=3.+5.*x[0]+12.*x[1]
410            # -------- test gradient --------------------------------
412            # -------- set-up PDE -----------------------------------
413            pde=LinearPDE(domain,numEquations=1)
416            pde.setValue(A=kronecker(2),y=inner(g_ex,domain.getNormal()),Y=-20.)
417            # -------- get the solution ---------------------------
418            pde.setTolerance(SOLVER_TOL)
419            pde.setSolverMethod(pde.TFQMR,pde.JACOBI)
420            pde.setSolverPackage(pde.PASO)
421            u=pde.getSolution(verbose=SOLVER_VERBOSE)
422            # -------- test the solution ---------------------------
423            error=Lsup(u-u_ex)/Lsup(u_ex)
424            self.failUnless(error<REL_TOL*Lsup(u_ex), "solution error %s is too big."%error)
425
426    class SimpleSolve_Rectangle_Order1_SystemPDE_Paso_TFQMR_Jacobi(unittest.TestCase):
427         def test_solve(self):
428            domain=Rectangle(NE0,NE1,1,optimize=OPTIMIZE)
429            x=Solution(domain).getX()
430            # --- set exact solution ----
431            u_ex=Vector(0,Solution(domain))
432            u_ex[0]=1.+2.*x[0]+3.*x[1]
433            u_ex[1]=-1.+3.*x[0]+2.*x[1]
434            # --- set exact gradient -----------
435            g_ex=Data(0.,(2,2),Solution(domain))
436            g_ex[0,0]=2.
437            g_ex[0,1]=3.
438            g_ex[1,0]=3.
439            g_ex[1,1]=2.
440            # -------- test gradient --------------------------------
442            # -------- set-up PDE -----------------------------------
443            pde=LinearPDE(domain,numEquations=2)
446            A=Tensor4(0,Function(domain))
447            A[0,:,0,:]=kronecker(2)
448            A[1,:,1,:]=kronecker(2)
449            Y=Vector(0.,Function(domain))
450            Y[0]=u_ex[0]*FAC_DIAG+u_ex[1]*FAC_OFFDIAG
451            Y[1]=u_ex[1]*FAC_DIAG+u_ex[0]*FAC_OFFDIAG
452            pde.setValue(A=A,
453                         D=kronecker(2)*(FAC_DIAG-FAC_OFFDIAG)+numarray.ones((2,2))*FAC_OFFDIAG,
454                         Y=Y,
455                         y=matrixmult(g_ex,domain.getNormal()))
456            # -------- get the solution ---------------------------
457            pde.setTolerance(SOLVER_TOL)
458            pde.setSolverMethod(pde.TFQMR,pde.JACOBI)
459            pde.setSolverPackage(pde.PASO)
460            u=pde.getSolution(verbose=SOLVER_VERBOSE)
461            # -------- test the solution ---------------------------
462            error=Lsup(u-u_ex)/Lsup(u_ex)
463            self.failUnless(error<REL_TOL*Lsup(u_ex), "solution error %s is too big."%error)
464
465    class SimpleSolve_Rectangle_Order2_SystemPDE_Paso_TFQMR_Jacobi(unittest.TestCase):
466         def test_solve(self):
467            domain=Rectangle(NE0,NE1,2,optimize=OPTIMIZE)
468            x=Solution(domain).getX()
469            # --- set exact solution ----
470            u_ex=Vector(0,Solution(domain))
471            u_ex[0]=1.+2.*x[0]+3.*x[1]+4.*x[0]**2+5.*x[1]*x[0]+6.*x[1]**2
472            u_ex[1]=-1.+4.*x[0]+2.*x[1]+1.*x[0]**2+6.*x[1]*x[0]+4.*x[1]**2
473            # --- set exact gradient -----------
474            g_ex=Data(0.,(2,2),Solution(domain))
475            g_ex[0,0]=2.+8.*x[0]+5.*x[1]
476            g_ex[0,1]=3.+5.*x[0]+12.*x[1]
477            g_ex[1,0]=4.+2.*x[0]+6.*x[1]
478            g_ex[1,1]=2.+6.*x[0]+8.*x[1]
479            # -------- test gradient --------------------------------
481            # -------- set-up PDE -----------------------------------
482            pde=LinearPDE(domain,numEquations=2)
485            A=Tensor4(0,Function(domain))
486            A[0,:,0,:]=kronecker(2)
487            A[1,:,1,:]=kronecker(2)
488            Y=Vector(0.,Function(domain))
489            Y[0]=u_ex[0]*FAC_DIAG+u_ex[1]*FAC_OFFDIAG
490            Y[1]=u_ex[1]*FAC_DIAG+u_ex[0]*FAC_OFFDIAG
491            pde.setValue(A=A,
492                         D=kronecker(2)*(FAC_DIAG-FAC_OFFDIAG)+numarray.ones((2,2))*FAC_OFFDIAG,
493                         Y=Y-[20.,10.],
494                         y=matrixmult(g_ex,domain.getNormal()))
495            # -------- get the solution ---------------------------
496            pde.setTolerance(SOLVER_TOL)
497            pde.setSolverMethod(pde.TFQMR,pde.JACOBI)
498            pde.setSolverPackage(pde.PASO)
499            u=pde.getSolution(verbose=SOLVER_VERBOSE)
500            # -------- test the solution ---------------------------
501            error=Lsup(u-u_ex)/Lsup(u_ex)
502            self.failUnless(error<REL_TOL*Lsup(u_ex), "solution error %s is too big."%error)
503
504    class SimpleSolve_Brick_Order1_SinglePDE_Paso_TFQMR_Jacobi(unittest.TestCase):
505         def test_solve(self):
506            domain=Brick(NE0,NE1,NE2,1,optimize=OPTIMIZE)
507            x=Solution(domain).getX()
508            u_ex=1.+2.*x[0]+3.*x[1]+4.*x[2]
509            # --- set exact gradient -----------
510            g_ex=Data(0.,(3,),Solution(domain))
511            g_ex[0]=2.
512            g_ex[1]=3.
513            g_ex[2]=4.
514            # -------- test gradient --------------------------------
516            # -------- set-up PDE -----------------------------------
517            pde=LinearPDE(domain,numEquations=1)
520            pde.setValue(A=kronecker(3),y=inner(g_ex,domain.getNormal()))
521            # -------- get the solution ---------------------------
522            pde.setTolerance(SOLVER_TOL)
523            pde.setSolverMethod(pde.TFQMR,pde.JACOBI)
524            pde.setSolverPackage(pde.PASO)
525            u=pde.getSolution(verbose=SOLVER_VERBOSE)
526            # -------- test the solution ---------------------------
527            error=Lsup(u-u_ex)/Lsup(u_ex)
528            self.failUnless(error<REL_TOL*Lsup(u_ex), "solution error %s is too big."%error)
529
530    class SimpleSolve_Brick_Order1_SystemPDE_Paso_TFQMR_Jacobi(unittest.TestCase):
531         def test_solve(self):
532            domain=Brick(NE0,NE1,NE2,1,optimize=OPTIMIZE)
533            x=Solution(domain).getX()
534            # --- set exact solution ----
535            u_ex=Vector(0,Solution(domain))
536            u_ex[0]=1.+2.*x[0]+3.*x[1]+4.*x[2]
537            u_ex[1]=-1.+4.*x[0]+1.*x[1]-2.*x[2]
538            u_ex[2]=5.+8.*x[0]+4.*x[1]+5.*x[2]
539            # --- set exact gradient -----------
540            g_ex=Data(0.,(3,3),Solution(domain))
541            g_ex[0,0]=2.
542            g_ex[0,1]=3.
543            g_ex[0,2]=4.
544            g_ex[1,0]=4.
545            g_ex[1,1]=1.
546            g_ex[1,2]=-2.
547            g_ex[2,0]=8.
548            g_ex[2,1]=4.
549            g_ex[2,2]=5.
550            # -------- test gradient --------------------------------
552            # -------- set-up PDE -----------------------------------
553            pde=LinearPDE(domain,numEquations=3)
556            A=Tensor4(0,Function(domain))
557            A[0,:,0,:]=kronecker(3)
558            A[1,:,1,:]=kronecker(3)
559            A[2,:,2,:]=kronecker(3)
560            Y=Vector(0.,Function(domain))
561            Y[0]=u_ex[0]*FAC_DIAG+u_ex[2]*FAC_OFFDIAG+u_ex[1]*FAC_OFFDIAG
562            Y[1]=u_ex[1]*FAC_DIAG+u_ex[0]*FAC_OFFDIAG+u_ex[2]*FAC_OFFDIAG
563            Y[2]=u_ex[2]*FAC_DIAG+u_ex[1]*FAC_OFFDIAG+u_ex[0]*FAC_OFFDIAG
564            pde.setValue(A=A,
565                         D=kronecker(3)*(FAC_DIAG-FAC_OFFDIAG)+numarray.ones((3,3))*FAC_OFFDIAG,
566                         Y=Y,
567                         y=matrixmult(g_ex,domain.getNormal()))
568            # -------- get the solution ---------------------------
569            pde.setTolerance(SOLVER_TOL)
570            pde.setSolverMethod(pde.TFQMR,pde.JACOBI)
571            pde.setSolverPackage(pde.PASO)
572            u=pde.getSolution(verbose=SOLVER_VERBOSE)
573            # -------- test the solution ---------------------------
574            error=Lsup(u-u_ex)/Lsup(u_ex)
575            self.failUnless(error<REL_TOL*Lsup(u_ex), "solution error %s is too big."%error)
576
577    class SimpleSolve_Brick_Order2_SinglePDE_Paso_TFQMR_Jacobi(unittest.TestCase):
578         def test_solve(self):
579            domain=Brick(NE0,NE1,NE2,2,optimize=OPTIMIZE)
580            x=Solution(domain).getX()
581            # --- set exact solution ----
582            u_ex=1.+2.*x[0]+3.*x[1]+4.*x[2]+6.*x[0]*x[1]+7.*x[1]*x[2]+8.*x[2]*x[0]+9.*x[0]**2+10.*x[1]**2+11.*x[2]**2
583            # --- set exact gradient -----------
584            g_ex=Data(0.,(3,),Solution(domain))
585            g_ex[0]=2.+6.*x[1]+8.*x[2]+18.*x[0]
586            g_ex[1]=3.+6.*x[0]+7.*x[2]+20.*x[1]
587            g_ex[2]=4.+7.*x[1]+8.*x[0]+22.*x[2]
588            # -------- test gradient --------------------------------
590            # -------- set-up PDE -----------------------------------
591            pde=LinearPDE(domain,numEquations=1)
594            pde.setValue(A=kronecker(3),y=inner(g_ex,domain.getNormal()),Y=-60.)
595            # -------- get the solution ---------------------------
596            pde.setTolerance(SOLVER_TOL)
597            pde.setSolverMethod(pde.TFQMR,pde.JACOBI)
598            pde.setSolverPackage(pde.PASO)
599            u=pde.getSolution(verbose=SOLVER_VERBOSE)
600            # -------- test the solution ---------------------------
601            error=Lsup(u-u_ex)/Lsup(u_ex)
602            self.failUnless(error<REL_TOL*Lsup(u_ex), "solution error %s is too big."%error)
603
604    class SimpleSolve_Brick_Order2_SystemPDE_Paso_TFQMR_Jacobi(unittest.TestCase):
605         def test_solve(self):
606            domain=Brick(NE0,NE1,NE2,2,optimize=OPTIMIZE)
607            x=Solution(domain).getX()
608            # --- set exact solution ----
609            u_ex=Vector(0,Solution(domain))
610            u_ex[0]=1.+2.*x[0]+3.*x[1]+4.*x[2]+6.*x[0]*x[1]+7.*x[1]*x[2]+8.*x[2]*x[0]+9.*x[0]**2+10.*x[1]**2+11.*x[2]**2
611            u_ex[1]=2.+4.*x[0]+1.*x[1]-6.*x[2]+3.*x[0]*x[1]+2.*x[1]*x[2]-8.*x[2]*x[0]-2.*x[0]**2+7.*x[1]**2+5.*x[2]**2
612            u_ex[2]=-2.+7.*x[0]+9.*x[1]+2*x[2]-6.*x[0]*x[1]+8.*x[1]*x[2]+2.*x[2]*x[0]+2.*x[0]**2+8.*x[1]**2+1.*x[2]**2
613            # --- set exact gradient -----------
614            g_ex=Data(0.,(3,3),Solution(domain))
615            g_ex[0,0]=2.+6.*x[1]+8.*x[2]+18.*x[0]
616            g_ex[0,1]=3.+6.*x[0]+7.*x[2]+20.*x[1]
617            g_ex[0,2]=4.+7.*x[1]+8.*x[0]+22.*x[2]
618            g_ex[1,0]=4.+3.*x[1]-8.*x[2]-4.*x[0]
619            g_ex[1,1]=1+3.*x[0]+2.*x[2]+14.*x[1]
620            g_ex[1,2]=-6.+2.*x[1]-8.*x[0]+10.*x[2]
621            g_ex[2,0]=7.-6.*x[1]+2.*x[2]+4.*x[0]
622            g_ex[2,1]=9.-6.*x[0]+8.*x[2]+16.*x[1]
623            g_ex[2,2]=2+8.*x[1]+2.*x[0]+2.*x[2]
624            # -------- test gradient --------------------------------
626            # -------- set-up PDE -----------------------------------
627            pde=LinearPDE(domain,numEquations=3)
630            Y=Vector(0.,Function(domain))
631            Y[0]=u_ex[0]*FAC_DIAG+u_ex[2]*FAC_OFFDIAG+u_ex[1]*FAC_OFFDIAG
632            Y[1]=u_ex[1]*FAC_DIAG+u_ex[0]*FAC_OFFDIAG+u_ex[2]*FAC_OFFDIAG
633            Y[2]=u_ex[2]*FAC_DIAG+u_ex[1]*FAC_OFFDIAG+u_ex[0]*FAC_OFFDIAG
634            A=Tensor4(0,Function(domain))
635            A[0,:,0,:]=kronecker(3)
636            A[1,:,1,:]=kronecker(3)
637            A[2,:,2,:]=kronecker(3)
638            pde.setValue(A=A,
639                         D=kronecker(3)*(FAC_DIAG-FAC_OFFDIAG)+numarray.ones((3,3))*FAC_OFFDIAG,
640                         Y=Y-numarray.array([60.,20.,22.]),
641                         y=matrixmult(g_ex,domain.getNormal()))
642            # -------- get the solution ---------------------------
643            pde.setTolerance(SOLVER_TOL)
644            pde.setSolverMethod(pde.TFQMR,pde.JACOBI)
645            pde.setSolverPackage(pde.PASO)
646            u=pde.getSolution(verbose=SOLVER_VERBOSE)
647            # -------- test the solution ---------------------------
648            error=Lsup(u-u_ex)/Lsup(u_ex)
649            self.failUnless(error<REL_TOL*Lsup(u_ex), "solution error %s is too big."%error)
650
651
652    class SimpleSolve_Rectangle_Order1_SinglePDE_Paso_MINRES_Jacobi(unittest.TestCase):
653         def test_solve(self):
654            domain=Rectangle(NE0,NE1,1, optimize=OPTIMIZE)
655            x=Solution(domain).getX()
656            # --- set exact solution ----
657            u_ex=Scalar(0,Solution(domain))
658            u_ex=1.+2.*x[0]+3.*x[1]
659            # --- set exact gradient -----------
660            g_ex=Data(0.,(2,),Solution(domain))
661            g_ex[0]=2.
662            g_ex[1]=3.
663            # -------- test gradient --------------------------------
665            self.failUnless(Lsup(g_ex-g)<REL_TOL*Lsup(g_ex))
666            # -------- set-up PDE -----------------------------------
667            pde=LinearPDE(domain,numEquations=1)
670            pde.setValue(A=kronecker(2),y=inner(g_ex,domain.getNormal()))
671            # -------- get the solution ---------------------------
672            pde.setTolerance(SOLVER_TOL)
673            pde.setSolverMethod(pde.MINRES,pde.JACOBI)
674            pde.setSolverPackage(pde.PASO)
675
676            u=pde.getSolution(verbose=SOLVER_VERBOSE)
677            # -------- test the solution ---------------------------
678            error=Lsup(u-u_ex)/Lsup(u_ex)
679            self.failUnless(error<REL_TOL*Lsup(u_ex), "solution error %s is too big."%error)
680
681    class SimpleSolve_Rectangle_Order2_SinglePDE_Paso_MINRES_Jacobi(unittest.TestCase):
682         def test_solve(self):
683            domain=Rectangle(NE0,NE1,2,l0=1.,l1=1,optimize=OPTIMIZE)
684            x=Solution(domain).getX()
685            # --- set exact solution ----
686            u_ex=1.+2.*x[0]+3.*x[1]+4.*x[0]**2+5.*x[1]*x[0]+6.*x[1]**2
687            # --- set exact gradient -----------
688            g_ex=Data(0.,(2,),Solution(domain))
689            g_ex[0]=2.+8.*x[0]+5.*x[1]
690            g_ex[1]=3.+5.*x[0]+12.*x[1]
691            # -------- test gradient --------------------------------
693            # -------- set-up PDE -----------------------------------
694            pde=LinearPDE(domain,numEquations=1)
697            pde.setValue(A=kronecker(2),y=inner(g_ex,domain.getNormal()),Y=-20.)
698            # -------- get the solution ---------------------------
699            pde.setTolerance(SOLVER_TOL)
700            pde.setSolverMethod(pde.MINRES,pde.JACOBI)
701            pde.setSolverPackage(pde.PASO)
702            u=pde.getSolution(verbose=SOLVER_VERBOSE)
703            # -------- test the solution ---------------------------
704            error=Lsup(u-u_ex)/Lsup(u_ex)
705            self.failUnless(error<REL_TOL*Lsup(u_ex), "solution error %s is too big."%error)
706
707    class SimpleSolve_Rectangle_Order1_SystemPDE_Paso_MINRES_Jacobi(unittest.TestCase):
708         def test_solve(self):
709            domain=Rectangle(NE0,NE1,1,optimize=OPTIMIZE)
710            x=Solution(domain).getX()
711            # --- set exact solution ----
712            u_ex=Vector(0,Solution(domain))
713            u_ex[0]=1.+2.*x[0]+3.*x[1]
714            u_ex[1]=-1.+3.*x[0]+2.*x[1]
715            # --- set exact gradient -----------
716            g_ex=Data(0.,(2,2),Solution(domain))
717            g_ex[0,0]=2.
718            g_ex[0,1]=3.
719            g_ex[1,0]=3.
720            g_ex[1,1]=2.
721            # -------- test gradient --------------------------------
723            # -------- set-up PDE -----------------------------------
724            pde=LinearPDE(domain,numEquations=2)
727            A=Tensor4(0,Function(domain))
728            A[0,:,0,:]=kronecker(2)
729            A[1,:,1,:]=kronecker(2)
730            Y=Vector(0.,Function(domain))
731            Y[0]=u_ex[0]*FAC_DIAG+u_ex[1]*FAC_OFFDIAG
732            Y[1]=u_ex[1]*FAC_DIAG+u_ex[0]*FAC_OFFDIAG
733            pde.setValue(A=A,
734                         D=kronecker(2)*(FAC_DIAG-FAC_OFFDIAG)+numarray.ones((2,2))*FAC_OFFDIAG,
735                         Y=Y,
736                         y=matrixmult(g_ex,domain.getNormal()))
737            # -------- get the solution ---------------------------
738            pde.setTolerance(SOLVER_TOL)
739            pde.setSolverMethod(pde.MINRES,pde.JACOBI)
740            pde.setSolverPackage(pde.PASO)
741            u=pde.getSolution(verbose=SOLVER_VERBOSE)
742            # -------- test the solution ---------------------------
743            error=Lsup(u-u_ex)/Lsup(u_ex)
744            self.failUnless(error<REL_TOL*Lsup(u_ex), "solution error %s is too big."%error)
745
746    class SimpleSolve_Rectangle_Order2_SystemPDE_Paso_MINRES_RILU(unittest.TestCase):
747         def test_solve(self):
748            domain=Rectangle(NE0,NE1,2,optimize=OPTIMIZE)
749            x=Solution(domain).getX()
750            # --- set exact solution ----
751            u_ex=Vector(0,Solution(domain))
752            u_ex[0]=1.+2.*x[0]+3.*x[1]+4.*x[0]**2+5.*x[1]*x[0]+6.*x[1]**2
753            u_ex[1]=-1.+4.*x[0]+2.*x[1]+1.*x[0]**2+6.*x[1]*x[0]+4.*x[1]**2
754            # --- set exact gradient -----------
755            g_ex=Data(0.,(2,2),Solution(domain))
756            g_ex[0,0]=2.+8.*x[0]+5.*x[1]
757            g_ex[0,1]=3.+5.*x[0]+12.*x[1]
758            g_ex[1,0]=4.+2.*x[0]+6.*x[1]
759            g_ex[1,1]=2.+6.*x[0]+8.*x[1]
760            # -------- test gradient --------------------------------
762            # -------- set-up PDE -----------------------------------
763            pde=LinearPDE(domain,numEquations=2)
766            A=Tensor4(0,Function(domain))
767            A[0,:,0,:]=kronecker(2)
768            A[1,:,1,:]=kronecker(2)
769            Y=Vector(0.,Function(domain))
770            Y[0]=u_ex[0]*FAC_DIAG+u_ex[1]*FAC_OFFDIAG
771            Y[1]=u_ex[1]*FAC_DIAG+u_ex[0]*FAC_OFFDIAG
772            pde.setValue(A=A,
773                         D=kronecker(2)*(FAC_DIAG-FAC_OFFDIAG)+numarray.ones((2,2))*FAC_OFFDIAG,
774                         Y=Y-[20.,10.],
775                         y=matrixmult(g_ex,domain.getNormal()))
776            # -------- get the solution ---------------------------
777            pde.setTolerance(SOLVER_TOL)
778            pde.setSolverMethod(pde.MINRES,pde.RILU)
779            pde.setSolverPackage(pde.PASO)
780            u=pde.getSolution(verbose=SOLVER_VERBOSE)
781            # -------- test the solution ---------------------------
782            error=Lsup(u-u_ex)/Lsup(u_ex)
783            self.failUnless(error<REL_TOL*Lsup(u_ex), "solution error %s is too big."%error)
784
785    class SimpleSolve_Brick_Order1_SinglePDE_Paso_MINRES_Jacobi(unittest.TestCase):
786         def test_solve(self):
787            domain=Brick(NE0,NE1,NE2,1,optimize=OPTIMIZE)
788            x=Solution(domain).getX()
789            u_ex=1.+2.*x[0]+3.*x[1]+4.*x[2]
790            # --- set exact gradient -----------
791            g_ex=Data(0.,(3,),Solution(domain))
792            g_ex[0]=2.
793            g_ex[1]=3.
794            g_ex[2]=4.
795            # -------- test gradient --------------------------------
797            # -------- set-up PDE -----------------------------------
798            pde=LinearPDE(domain,numEquations=1)
801            pde.setValue(A=kronecker(3),y=inner(g_ex,domain.getNormal()))
802            # -------- get the solution ---------------------------
803            pde.setTolerance(SOLVER_TOL)
804            pde.setSolverMethod(pde.MINRES,pde.JACOBI)
805            pde.setSolverPackage(pde.PASO)
806            u=pde.getSolution(verbose=SOLVER_VERBOSE)
807            # -------- test the solution ---------------------------
808            error=Lsup(u-u_ex)/Lsup(u_ex)
809            self.failUnless(error<REL_TOL*Lsup(u_ex), "solution error %s is too big."%error)
810
811    class SimpleSolve_Brick_Order1_SystemPDE_Paso_MINRES_Jacobi(unittest.TestCase):
812         def test_solve(self):
813            domain=Brick(NE0,NE1,NE2,1,optimize=OPTIMIZE)
814            x=Solution(domain).getX()
815            # --- set exact solution ----
816            u_ex=Vector(0,Solution(domain))
817            u_ex[0]=1.+2.*x[0]+3.*x[1]+4.*x[2]
818            u_ex[1]=-1.+4.*x[0]+1.*x[1]-2.*x[2]
819            u_ex[2]=5.+8.*x[0]+4.*x[1]+5.*x[2]
820            # --- set exact gradient -----------
821            g_ex=Data(0.,(3,3),Solution(domain))
822            g_ex[0,0]=2.
823            g_ex[0,1]=3.
824            g_ex[0,2]=4.
825            g_ex[1,0]=4.
826            g_ex[1,1]=1.
827            g_ex[1,2]=-2.
828            g_ex[2,0]=8.
829            g_ex[2,1]=4.
830            g_ex[2,2]=5.
831            # -------- test gradient --------------------------------
833            # -------- set-up PDE -----------------------------------
834            pde=LinearPDE(domain,numEquations=3)
837            A=Tensor4(0,Function(domain))
838            A[0,:,0,:]=kronecker(3)
839            A[1,:,1,:]=kronecker(3)
840            A[2,:,2,:]=kronecker(3)
841            Y=Vector(0.,Function(domain))
842            Y[0]=u_ex[0]*FAC_DIAG+u_ex[2]*FAC_OFFDIAG+u_ex[1]*FAC_OFFDIAG
843            Y[1]=u_ex[1]*FAC_DIAG+u_ex[0]*FAC_OFFDIAG+u_ex[2]*FAC_OFFDIAG
844            Y[2]=u_ex[2]*FAC_DIAG+u_ex[1]*FAC_OFFDIAG+u_ex[0]*FAC_OFFDIAG
845            pde.setValue(A=A,
846                         D=kronecker(3)*(FAC_DIAG-FAC_OFFDIAG)+numarray.ones((3,3))*FAC_OFFDIAG,
847                         Y=Y,
848                         y=matrixmult(g_ex,domain.getNormal()))
849            # -------- get the solution ---------------------------
850            pde.setTolerance(SOLVER_TOL)
851            pde.setSolverMethod(pde.MINRES,pde.JACOBI)
852            pde.setSolverPackage(pde.PASO)
853            u=pde.getSolution(verbose=SOLVER_VERBOSE)
854            # -------- test the solution ---------------------------
855            error=Lsup(u-u_ex)/Lsup(u_ex)
856            self.failUnless(error<REL_TOL*Lsup(u_ex), "solution error %s is too big."%error)
857
858    class SimpleSolve_Brick_Order2_SinglePDE_Paso_MINRES_RILU(unittest.TestCase):
859         def test_solve(self):
860            domain=Brick(NE0,NE1,NE2,2,optimize=OPTIMIZE)
861            x=Solution(domain).getX()
862            # --- set exact solution ----
863            u_ex=1.+2.*x[0]+3.*x[1]+4.*x[2]+6.*x[0]*x[1]+7.*x[1]*x[2]+8.*x[2]*x[0]+9.*x[0]**2+10.*x[1]**2+11.*x[2]**2
864            # --- set exact gradient -----------
865            g_ex=Data(0.,(3,),Solution(domain))
866            g_ex[0]=2.+6.*x[1]+8.*x[2]+18.*x[0]
867            g_ex[1]=3.+6.*x[0]+7.*x[2]+20.*x[1]
868            g_ex[2]=4.+7.*x[1]+8.*x[0]+22.*x[2]
869            # -------- test gradient --------------------------------
871            # -------- set-up PDE -----------------------------------
872            pde=LinearPDE(domain,numEquations=1)
875            pde.setValue(A=kronecker(3),y=inner(g_ex,domain.getNormal()),Y=-60.)
876            # -------- get the solution ---------------------------
877            pde.setTolerance(SOLVER_TOL)
878            pde.setSolverMethod(pde.MINRES,pde.RILU)
879            pde.setSolverPackage(pde.PASO)
880            u=pde.getSolution(verbose=SOLVER_VERBOSE)
881            # -------- test the solution ---------------------------
882            error=Lsup(u-u_ex)/Lsup(u_ex)
883            self.failUnless(error<REL_TOL*Lsup(u_ex), "solution error %s is too big."%error)
884
885    class SimpleSolve_Brick_Order2_SystemPDE_Paso_MINRES_RILU(unittest.TestCase):
886         def test_solve(self):
887            domain=Brick(NE0,NE1,NE2,2,optimize=OPTIMIZE)
888            x=Solution(domain).getX()
889            # --- set exact solution ----
890            u_ex=Vector(0,Solution(domain))
891            u_ex[0]=1.+2.*x[0]+3.*x[1]+4.*x[2]+6.*x[0]*x[1]+7.*x[1]*x[2]+8.*x[2]*x[0]+9.*x[0]**2+10.*x[1]**2+11.*x[2]**2
892            u_ex[1]=2.+4.*x[0]+1.*x[1]-6.*x[2]+3.*x[0]*x[1]+2.*x[1]*x[2]-8.*x[2]*x[0]-2.*x[0]**2+7.*x[1]**2+5.*x[2]**2
893            u_ex[2]=-2.+7.*x[0]+9.*x[1]+2*x[2]-6.*x[0]*x[1]+8.*x[1]*x[2]+2.*x[2]*x[0]+2.*x[0]**2+8.*x[1]**2+1.*x[2]**2
894            # --- set exact gradient -----------
895            g_ex=Data(0.,(3,3),Solution(domain))
896            g_ex[0,0]=2.+6.*x[1]+8.*x[2]+18.*x[0]
897            g_ex[0,1]=3.+6.*x[0]+7.*x[2]+20.*x[1]
898            g_ex[0,2]=4.+7.*x[1]+8.*x[0]+22.*x[2]
899            g_ex[1,0]=4.+3.*x[1]-8.*x[2]-4.*x[0]
900            g_ex[1,1]=1+3.*x[0]+2.*x[2]+14.*x[1]
901            g_ex[1,2]=-6.+2.*x[1]-8.*x[0]+10.*x[2]
902            g_ex[2,0]=7.-6.*x[1]+2.*x[2]+4.*x[0]
903            g_ex[2,1]=9.-6.*x[0]+8.*x[2]+16.*x[1]
904            g_ex[2,2]=2+8.*x[1]+2.*x[0]+2.*x[2]
905            # -------- test gradient --------------------------------
907            # -------- set-up PDE -----------------------------------
908            pde=LinearPDE(domain,numEquations=3)
911            Y=Vector(0.,Function(domain))
912            Y[0]=u_ex[0]*FAC_DIAG+u_ex[2]*FAC_OFFDIAG+u_ex[1]*FAC_OFFDIAG
913            Y[1]=u_ex[1]*FAC_DIAG+u_ex[0]*FAC_OFFDIAG+u_ex[2]*FAC_OFFDIAG
914            Y[2]=u_ex[2]*FAC_DIAG+u_ex[1]*FAC_OFFDIAG+u_ex[0]*FAC_OFFDIAG
915            A=Tensor4(0,Function(domain))
916            A[0,:,0,:]=kronecker(3)
917            A[1,:,1,:]=kronecker(3)
918            A[2,:,2,:]=kronecker(3)
919            pde.setValue(A=A,
920                         D=kronecker(3)*(FAC_DIAG-FAC_OFFDIAG)+numarray.ones((3,3))*FAC_OFFDIAG,
921                         Y=Y-numarray.array([60.,20.,22.]),
922                         y=matrixmult(g_ex,domain.getNormal()))
923            # -------- get the solution ---------------------------
924            pde.setTolerance(SOLVER_TOL)
925            pde.setSolverMethod(pde.MINRES,pde.RILU)
926            pde.setSolverPackage(pde.PASO)
927            u=pde.getSolution(verbose=SOLVER_VERBOSE)
928            # -------- test the solution ---------------------------
929            error=Lsup(u-u_ex)/Lsup(u_ex)
930            self.failUnless(error<REL_TOL*Lsup(u_ex), "solution error %s is too big."%error)
931
932  if __name__ == '__main__':  if __name__ == '__main__':
933     suite = unittest.TestSuite()     suite = unittest.TestSuite()
# Line 409  if __name__ == '__main__': Line 941  if __name__ == '__main__':