Esempio n. 1
0
 def test_Brick_ReducedFunction(self):
     ranks = getMPISizeWorld()
     for order in range(2, 11):
         dom = Brick(order,
                     3,
                     3 * ranks,
                     3,
                     l0=3,
                     l1=3 * ranks,
                     l2=3,
                     d1=ranks)
         X = dom.getX()
         redData = interpolate(X, ReducedFunction(dom))
         data = [(interpolate(redData,
                              ReducedFunction(dom)), "ReducedFunction"),
                 (interpolate(redData, Function(dom)), "Function"),
                 (interpolate(redData, ContinuousFunction(dom)),
                  "ContinuousFunction")]
         for d, fs in data:
             self.assertLess(
                 inf(d - [0.5] * 3), self.TOLERANCE,
                 "reduced->%s failure with order %d: %e != 0" %
                 (fs, order, inf(d - [0.5] * 3)))
             self.assertLess(
                 sup(d[0] + 0.5) - 3, self.TOLERANCE,
                 "reduced->%s failure with order %d: %e != 3" %
                 (fs, order, sup(d[0] + 0.5)))
             self.assertLess(
                 sup(d[1] + 0.5) - 3 * ranks, self.TOLERANCE,
                 "reduced->%s failure with order %d: %e >= %e" %
                 (fs, order, sup(d[1] + 0.5) - 3 * ranks, self.TOLERANCE))
             self.assertLess(
                 sup(d[2] + 0.5) - 3, self.TOLERANCE,
                 "reduced->%s failure with order %d: %e != 3" %
                 (fs, order, sup(d[2] + 0.5)))
 def generateBricks(self, order, a, b, c):
     brickX = Brick(order,
                    self.longEdge,
                    5,
                    5,
                    l0=self.longEdge,
                    l1=5,
                    l2=5,
                    d0=self.numRanks,
                    diracPoints=[(a, b, c)],
                    diracTags=["test"])
     brickY = Brick(order,
                    5,
                    self.longEdge,
                    5,
                    l0=5,
                    l1=self.longEdge,
                    l2=self.shortEdge,
                    d1=self.numRanks,
                    diracPoints=[(c, a, b)],
                    diracTags=["test"])
     brickZ = Brick(order,
                    5,
                    5,
                    self.longEdge,
                    l0=5,
                    l1=5,
                    l2=self.longEdge,
                    d2=self.numRanks,
                    diracPoints=[(b, c, a)],
                    diracTags=["test"])
     dims = [[self.longEdge, 5, 5], [5, self.longEdge, 5],
             [5, 5, self.longEdge]]
     return [brickX, brickY, brickZ], dims
    def test_Brick_ContinuousFunction_gradient(self):
        ranks = getMPISizeWorld()
        for order in range(2,11):
            dom = Brick(order, 3, 3*ranks, 3, l0=100, l1=100, l2=100, d1=ranks)
            X = dom.getX()
            u = X[0] + X[1] + X[2] + 1
            v = Lsup(grad(u) - 1)
            self.assertLess(v, 1e-10, "order %d, %e >= 1e-10, %s"%(order, v,
                    str(grad(u)-1)))
            for power1 in range(1, order+1, order//2):
                for power2 in range(1, order+1, order//2):
                    for power3 in range(1, order+1, order//2):
                        a = X[0]**power1 * X[1]**power2 * X[2]**power3
                        da = grad(a)

                        temp = power1*X[0]**(power1-1) * X[1]**power2*X[2]**power3
                        first = Lsup(da[0] - temp) / Lsup(temp)
                        temp = power2*X[1]**(power2-1) * X[0]**power1*X[2]**power3
                        second = Lsup(da[1] - temp) / Lsup(temp)
                        temp = power3*X[2]**(power3-1) * X[0]**power1*X[1]**power2
                        third = Lsup(da[2] - temp) / Lsup(temp)
                                
                        self.assertLess(first, 1e-10,
                            "order %d and degree %d,%d,%d, %e >= 1e-9"%(order,
                            power1, power2, power3, first))
                        self.assertLess(second, 1e-10,
                            "order %d and degree %d,%d,%d, %e >= 1e-9"%(order,
                            power1, power2, power3, second))
                        self.assertLess(third, 1e-10,
                            "order %d and degree %d,%d,%d, %e >= 1e-9"%(order,
                            power1, power2, power3, third))
Esempio n. 4
0
 def xtest_Brick_interpolation_continuous_noncontinuous_and_back(self):
     ranks = getMPISizeWorld()
     for order in range(2, 11):
         dom = Brick(order, 3, 3 * ranks, 3, l0=6, l1=ranks, l2=6, d1=ranks)
         original = Data(5, Function(dom), True)
         cont = interpolate(original, ContinuousFunction(dom))
         func = interpolate(cont, Function(dom))
         self.assertEqual(
             Lsup(original - func), 0,
             "interpolation of constant, order %d: original and final not equal, %e != 0"
             % (order, Lsup(original - func)))
         x = dom.getX()
         original = x[0] + x[1] + x[2] + 1
         cont = interpolate(original, ContinuousFunction(dom))
         func = interpolate(cont, Function(dom))
         self.assertEqual(
             Lsup(original - func), 0,
             "interpolation of expanded, order %d: original and final not equal, %e != 0"
             % (order, Lsup(original - func)))
         original = whereZero(x[0] - 2) + whereZero(x[1] -
                                                    2) + whereZero(x[2] - 2)
         cont = interpolate(original, ContinuousFunction(dom))
         func = interpolate(cont, Function(dom))
         self.assertEqual(
             Lsup(original - func), 0,
             "interpolation of point, order %d: original and final not equal, %e != 0"
             % (order, Lsup(original - func)))
Esempio n. 5
0
 def xtest_Brick_multidim_subdivision(self):
     ranks = getMPISizeWorld()
     half = 2  #change if ranks != 4 (sqrt(ranks))
     for order in range(2, 11):
         for dom, dim1, dim2 in [(Brick(order,
                                        2 * half,
                                        2 * half,
                                        2,
                                        l0=half,
                                        l1=half,
                                        d0=half,
                                        d1=half), 0, 1),
                                 (Brick(order,
                                        2 * half,
                                        2,
                                        2 * half,
                                        l0=half,
                                        l2=half,
                                        d0=half,
                                        d2=half), 0, 2),
                                 (Brick(order,
                                        2,
                                        2 * half,
                                        2 * half,
                                        l1=half,
                                        l2=half,
                                        d1=half,
                                        d2=half), 1, 2)]:
             self.assertEqual(ranks + 1,
                     Lsup(dom.getX()[0] + dom.getX()[1] + dom.getX()[2]),
                     "invalid getX() for multidimensional split " + \
                     "(dims %d,%d) in order %d"%(dim1,dim2,order))
             xfilt = whereZero(dom.getX()[dim1] - 1) \
                     + whereZero(dom.getX()[dim2] - 1)
             for i in range(2, half):
                 xfilt += whereZero(dom.getX()[dim1] - i)
                 xfilt += whereZero(dom.getX()[dim2] - i)
             xfilt = whereNonZero(xfilt)
             if getMPIRankWorld() in [1, 2]:  #change if ranks != 4
                 xfilt *= -1
             X = interpolate(xfilt, Function(dom))
             res = interpolate(X, ContinuousFunction(dom))
             val = Lsup(res)
             self.assertEqual(val, 0,
                 "summation failure for mixed-splits " \
                 + "(dims %d,%d) in order %d"%(dim1,dim2,order))
             X = interpolate(xfilt + 2, Function(dom))
             res = interpolate(X, ContinuousFunction(dom))
             val = Lsup(res - 2)
             self.assertEqual(val, 0,
                 "averaging failure for mixed-splits "\
                 + "(dims %d,%d) in order %d"%(dim1,dim2,order))
Esempio n. 6
0
    def test_Brick_Du_Y_system(self):
        #solves for u in Du = Y, where D = [1,2], Y = [2,4]
        ranks = getMPISizeWorld()
        for expanded in (True, False):
            for order in range(2, 11):
                dom = Brick(order, 3, 3 * ranks, 3, d1=ranks)
                D = Data(1, (2, ), ContinuousFunction(dom), expanded)
                D[1] = 2
                Y = Data(2, (2, ), ContinuousFunction(dom), expanded)
                Y[1] = 4

                Y = interpolate(Y, Function(dom))
                D = interpolate(D, Function(dom))

                rhs = Data(0, (2, ), Solution(dom), expanded)
                lhs = Data(0, (2, ), Solution(dom), expanded)

                dom.addToRHS(rhs, [("Y", Y)],
                             dom.createAssembler("DefaultAssembler", []))
                dom.addToRHS(lhs, [("D", D)],
                             dom.createAssembler("DefaultAssembler", []))

                res = Lsup((rhs / lhs) - 2)
                self.assertLess(
                    res, self.TOLERANCE,
                    ("assembly for {0}expanded order %d failed with %e >= %e" %
                     (order, res,
                      self.TOLERANCE)).format("" if expanded else "un-"))
Esempio n. 7
0
 def test_complex_params_Brick(self):
     domain=Brick(order=2,n0=10,n1=10,n2=10)
     pde = LinearSinglePDE(domain, isComplex=True)
     pde.setValue(D=1j)
     pde.setValue(Y=1.0)
     self.assertTrue(Lsup(pde.getSolution())==1.0, "Failed test_complex_params_Brick")
     del domain
 def test_Brick_integration(self):
     ranks = getMPISizeWorld()
     for order in range(2,11):
         size = 6
         dom = Brick(order, 3, 3*ranks, 3, l0=6, l1=6, l2=6, d1=ranks)
         X = dom.getX()
         for k in [1, order, order*2 - 1]:
             for l in [1, order, order*2 - 1]:
                 for m in [1, order, order*2 - 1]:
                     powered = X[0]**k * X[1]**l * X[2]**m
                     integral = integrate(powered)
                     actual = size**(k+1) * size**(l+1) * size**(m+1) \
                             /((k+1.)*(l+1.)*(m+1.))
                     res = abs(integral - actual)/actual
                     self.assertLess(res, 1e-11,
                             "too much variance in integral result (order %d, degrees %d %d, %e >= 1e-11)"%(order,
                             k, l, res))
    def test_Brick_Du_Y_system(self):
        #solves for u in Du = Y, where D = [1,2], Y = [2,4]
        ranks = getMPISizeWorld()
        for expanded in (True, False):
            for order in range(2,11):
                dom = Brick(order, 3, 3*ranks, 3, d1=ranks)
                D = Data(1, (2,), ContinuousFunction(dom), expanded)
                D[1] = 2
                Y = Data(2, (2,), ContinuousFunction(dom), expanded)
                Y[1] = 4

                Y = interpolate(Y, Function(dom))
                D = interpolate(D, Function(dom))
                
                rhs = Data(0, (2,), Solution(dom), expanded)
                lhs = Data(0, (2,), Solution(dom), expanded)

                dom.addToRHS(rhs, [("Y",Y)],
                        dom.createAssembler("DefaultAssembler", []))
                dom.addToRHS(lhs, [("D",D)],
                        dom.createAssembler("DefaultAssembler", []))
                
                res = Lsup((rhs/lhs)-2)
                self.assertLess(res, self.TOLERANCE,
                        ("assembly for {0}expanded order %d failed with %e >= %e"%(order,
                        res, self.TOLERANCE)).format("" if expanded else "un-"))
Esempio n. 10
0
    def test_Brick_ContinuousFunction_gradient(self):
        ranks = getMPISizeWorld()
        for order in range(2, 11):
            dom = Brick(order,
                        3,
                        3 * ranks,
                        3,
                        l0=100,
                        l1=100,
                        l2=100,
                        d1=ranks)
            X = dom.getX()
            u = X[0] + X[1] + X[2] + 1
            v = Lsup(grad(u) - 1)
            self.assertLess(
                v, 1e-10,
                "order %d, %e >= 1e-10, %s" % (order, v, str(grad(u) - 1)))
            for power1 in range(1, order + 1, order // 2):
                for power2 in range(1, order + 1, order // 2):
                    for power3 in range(1, order + 1, order // 2):
                        a = X[0]**power1 * X[1]**power2 * X[2]**power3
                        da = grad(a)

                        temp = power1 * X[0]**(power1 -
                                               1) * X[1]**power2 * X[2]**power3
                        first = Lsup(da[0] - temp) / Lsup(temp)
                        temp = power2 * X[1]**(power2 -
                                               1) * X[0]**power1 * X[2]**power3
                        second = Lsup(da[1] - temp) / Lsup(temp)
                        temp = power3 * X[2]**(power3 -
                                               1) * X[0]**power1 * X[1]**power2
                        third = Lsup(da[2] - temp) / Lsup(temp)

                        self.assertLess(
                            first, 1e-10,
                            "order %d and degree %d,%d,%d, %e >= 1e-9" %
                            (order, power1, power2, power3, first))
                        self.assertLess(
                            second, 1e-10,
                            "order %d and degree %d,%d,%d, %e >= 1e-9" %
                            (order, power1, power2, power3, second))
                        self.assertLess(
                            third, 1e-10,
                            "order %d and degree %d,%d,%d, %e >= 1e-9" %
                            (order, power1, power2, power3, third))
Esempio n. 11
0
 def xtest_Brick_integration(self):
     ranks = getMPISizeWorld()
     for order in range(2, 11):
         size = 6
         dom = Brick(order, 3, 3 * ranks, 3, l0=6, l1=6, l2=6, d1=ranks)
         X = dom.getX()
         for k in [1, order, order * 2 - 1]:
             for l in [1, order, order * 2 - 1]:
                 for m in [1, order, order * 2 - 1]:
                     powered = X[0]**k * X[1]**l * X[2]**m
                     integral = integrate(powered)
                     actual = size**(k+1) * size**(l+1) * size**(m+1) \
                             /((k+1.)*(l+1.)*(m+1.))
                     res = abs(integral - actual) / actual
                     self.assertLess(
                         res, 1e-11,
                         "too much variance in integral result (order %d, degrees %d %d, %e >= 1e-11)"
                         % (order, k, l, res))
Esempio n. 12
0
 def test_Brick_ReducedFunction(self):
     ranks = getMPISizeWorld()
     for order in range(2, 11):
         dom = Brick(order, 3, 3*ranks, 3, l0=3, l1=3*ranks, l2=3, d1=ranks)
         X = dom.getX()
         redData = interpolate(X, ReducedFunction(dom))
         data = [(interpolate(redData, ReducedFunction(dom)), "ReducedFunction"),
                 (interpolate(redData, Function(dom)), "Function"),
                 (interpolate(redData, ContinuousFunction(dom)), "ContinuousFunction")]
         for d, fs in data:
             self.assertLess(inf(d-[0.5]*3), self.TOLERANCE,
                     "reduced->%s failure with order %d: %e != 0"%(fs, order, inf(d-[0.5]*3)))
             self.assertLess(sup(d[0]+0.5) - 3, self.TOLERANCE,
                     "reduced->%s failure with order %d: %e != 3"%(fs, order, sup(d[0]+0.5)))
             self.assertLess(sup(d[1]+0.5) - 3*ranks, self.TOLERANCE,
                     "reduced->%s failure with order %d: %e >= %e"%(fs, order, sup(d[1]+0.5)-3*ranks, self.TOLERANCE))
             self.assertLess(sup(d[2]+0.5) - 3, self.TOLERANCE,
                     "reduced->%s failure with order %d: %e != 3"%(fs, order, sup(d[2]+0.5)))
Esempio n. 13
0
 def test_Brick_Function_gradient_Simetric(
         self):  #expanded and non-expanded
     ranks = getMPISizeWorld()
     for expanded in [True, False]:
         for order in range(2, 11):
             dom = Brick(order, 3, 3 * ranks, 3, d1=ranks)
             x = ContinuousFunction(dom).getX()
             m = -2 * 1j + 4
             b = 3 + 8 * 1j
             f = Vector(0., Solution(dom))
             sample_data = [[
                 0.000000000 + 0.000000000j, 4.000000000 - 2.000000000j,
                 8.000000000 - 4.000000000j
             ],
                            [
                                4.000000000 - 2.000000000j,
                                8.000000000 - 4.000000000j,
                                12.000000000 - 6.000000000j
                            ],
                            [
                                8.000000000 - 4.000000000j,
                                12.000000000 - 6.000000000j,
                                16.000000000 - 8.000000000j
                            ]]
             sample = Data(sample_data, Function(dom), True)
             sample[0, 0] = 0.000000000 + 0.000000000j
             sample[0, 1] = 4.000000000 - 2.000000000j
             sample[0, 2] = 8.000000000 - 4.000000000j
             sample[1, 0] = 4.000000000 - 2.000000000j
             sample[1, 1] = 8.000000000 - 4.000000000j
             sample[1, 2] = 12.000000000 - 6.000000000j
             sample[2, 0] = 8.000000000 - 4.000000000j
             sample[2, 1] = 12.000000000 - 6.000000000j
             sample[2, 2] = 16.000000000 - 8.000000000j
             for i in range(dom.getDim()):
                 for j in range(dom.getDim()):
                     f[i] += m * (i + j) * x[j] + b - i * j
             g = grad(f)
             self.assertLess(
                 Lsup(g - sample), 1e-9,
                 "single component failure, order %d%s, %e >= 1e-10" %
                 (order,
                  (" expanded" if expanded else ""), Lsup(g - sample)))
Esempio n. 14
0
 def test_Brick_interpolation_continuous_noncontinuous_and_back(self):
     ranks = getMPISizeWorld()
     for order in range(2,11):
         dom = Brick(order, 3, 3*ranks, 3, l0=6, l1=ranks, l2=6, d1=ranks)
         original = Data(5, Function(dom), True)
         cont = interpolate(original, ContinuousFunction(dom))
         func = interpolate(cont, Function(dom))
         self.assertEqual(Lsup(original-func), 0,
                 "interpolation of constant, order %d: original and final not equal, %e != 0"%(order, Lsup(original-func)))
         x = dom.getX()
         original = x[0] + x[1] + x[2] + 1
         cont = interpolate(original, ContinuousFunction(dom))
         func = interpolate(cont, Function(dom))
         self.assertEqual(Lsup(original-func), 0,
                 "interpolation of expanded, order %d: original and final not equal, %e != 0"%(order, Lsup(original-func)))
         original = whereZero(x[0]-2) + whereZero(x[1]-2) + whereZero(x[2] - 2)
         cont = interpolate(original, ContinuousFunction(dom))
         func = interpolate(cont, Function(dom))
         self.assertEqual(Lsup(original-func), 0,
                 "interpolation of point, order %d: original and final not equal, %e != 0"%(order, Lsup(original-func)))
Esempio n. 15
0
 def setUp(self):
     self.domains = []
     for order in range(2, 11):
         self.domains.append(
             Brick(order,
                   4,
                   4,
                   4,
                   diracTags=["source"],
                   diracPoints=[(0, 0, 0)]))
     self.wavelet = Ricker(100.)
Esempio n. 16
0
    def test_Brick_XY_single(self):
        ranks = getMPISizeWorld()
        for expanded in (True, False):
            for order in range(2,11):
                dom = Brick(order, 3, 3*ranks, 3, l0=6, l1=6, l2=6, d1=ranks)
                Y = Data(3, Function(dom), expanded)
                X = Data(0, (3,), Function(dom), expanded)
                X[0] = dom.getX()[0]
                X[1] = dom.getX()[1]
                X[2] = dom.getX()[2]
                f = Data(0, Solution(dom), expanded)

                dom.addToRHS(f, [("Y",Y)],
                        dom.createAssembler("DefaultAssembler", []))
                dom.addToRHS(f, [("X", X)],
                        dom.createAssembler("DefaultAssembler", []))
                #nuke the boundary back to zero since it's not dealt with here
                for dim in range(3):
                    f *= whereNegative(dom.getX()[dim]-6)
                res = Lsup(f)
                self.assertLess(res, self.TOLERANCE,
                        ("assembly for {0}expanded order %d failed with %e >= %e"%(order,
                        res, self.TOLERANCE)).format("" if expanded else "un-"))
Esempio n. 17
0
    def xtest_Brick_singledim_subdivision(self):
        ranks = getMPISizeWorld()
        for dim in range(0, 3):
            label = ["x", "y", "z"][dim]
            size = [2, 2, 2]
            size[dim] *= ranks
            lengths = [1, 1, 1]
            lengths[dim] *= ranks
            splits = [1, 1, 1]
            splits[dim] *= ranks

            for order in range(2, 11):
                dom = Brick(order,
                            size[0],
                            size[1],
                            size[2],
                            l0=lengths[0],
                            l1=lengths[1],
                            l2=lengths[2],
                            d0=splits[0],
                            d1=splits[1],
                            d2=splits[2])
                self.assertEqual(Lsup(dom.getX()[1]+dom.getX()[0]+dom.getX()[2]),
                        ranks+2, "invalid getX() for %s-splits order %d"%(\
                        label, order))

                filt = whereZero(dom.getX()[dim] - 1)
                for i in range(2, ranks):
                    filt += whereZero(dom.getX()[0] - i)
                if getMPIRankWorld() % 2:
                    filt *= -1
                d = Vector(0, Function(dom))
                d[0] = 1 * filt
                d[1] = 10 * filt
                d[2] = 100 * filt
                X = interpolate(d, Function(dom))
                res = interpolate(X, ContinuousFunction(dom))
                val = Lsup(res)
                self.assertEqual(val, 0,
                        "summation stage failure for %s-splits in order %d,"%(\
                        label, order))
                X = interpolate(d + 2, Function(dom))
                res = interpolate(X, ContinuousFunction(dom))
                val = Lsup(res - 2)
                self.assertEqual(val, 0,
                        "averaging stage failure for %s-splits in order %d,"%(\
                        label, order))
Esempio n. 18
0
 def test_Brick_Function_gradient(self):
     ranks = getMPISizeWorld()
     for expanded in [True, False]:
         for order in range(2, 11):
             dom = Brick(order, 3, 3 * ranks, 3, d1=ranks)
             x = Data(5, Function(dom), True)
             self.assertLess(
                 Lsup(grad(x)), 1e-10,
                 "single component failure, order %d%s, %e >= 1e-10" %
                 (order, (" expanded" if expanded else ""), Lsup(grad(x))))
             for data in [[5, 1], [-5, -1], [5, 1, 1e-5]]:
                 x = Data(data, Function(dom), True)
                 g = grad(x)
                 for n, d in enumerate(data):
                     self.assertLess(
                         Lsup(g[n]), 1e-10,
                         "%d-component failure, order %d %sexpanded, %e >= 1e-10"
                         % (len(data), order,
                            ("" if expanded else "un-"), Lsup(g[n])))
Esempio n. 19
0
    def test_Brick_singledim_subdivision(self):
        ranks = getMPISizeWorld()
        for dim in range(0,3):
            label = ["x","y","z"][dim]
            size = [2,2,2]
            size[dim] *= ranks
            lengths = [1,1,1]
            lengths[dim] *= ranks
            splits = [1,1,1]
            splits[dim] *= ranks
            
            for order in range(2, 11):
                dom = Brick(order, size[0], size[1], size[2], 
                                   l0=lengths[0], l1=lengths[1], l2=lengths[2],
                                   d0=splits[0], d1=splits[1], d2=splits[2])
                self.assertEqual(Lsup(dom.getX()[1]+dom.getX()[0]+dom.getX()[2]),
                        ranks+2, "invalid getX() for %s-splits order %d"%(\
                        label, order))

                filt = whereZero(dom.getX()[dim] - 1)
                for i in range(2,ranks):
                    filt += whereZero(dom.getX()[0] - i)
                if getMPIRankWorld() % 2:
                    filt *= -1
                d = Vector(0, Function(dom))
                d[0] = 1 * filt
                d[1] = 10 * filt
                d[2] = 100 * filt
                X = interpolate(d, Function(dom))
                res = interpolate(X, ContinuousFunction(dom))
                val = Lsup(res)
                self.assertEqual(val, 0, 
                        "summation stage failure for %s-splits in order %d,"%(\
                        label, order))
                X = interpolate(d+2, Function(dom))
                res = interpolate(X, ContinuousFunction(dom))
                val = Lsup(res-2)
                self.assertEqual(val, 0, 
                        "averaging stage failure for %s-splits in order %d,"%(\
                        label, order))    
    #
    order = 5
    if DIM == 2:
        domain = Rectangle(order,
                           ceil(ne_z * width_x / depth),
                           ne_z,
                           l0=width_x,
                           l1=depth,
                           diracPoints=src_locations,
                           diracTags=src_tags)
    else:
        domain = Brick(order,
                       ceil(ne_z * width_x / depth),
                       ceil(ne_z * width_y / depth),
                       ne_z,
                       l0=width_x,
                       l1=width_y,
                       l2=depth,
                       diracPoints=src_locations,
                       diracTags=src_tags)
    wl = Ricker(frq)
    m = whereNegative(Function(domain).getX()[DIM - 1] - reflector_at)
    v_p = v_p_bottom * m + v_p_top * (1 - m)

    sw = SonicWave(domain,
                   v_p,
                   source_tag=src_tags[0],
                   wavelet=wl,
                   absorption_zone=absorption_zone,
                   lumping=True)
Esempio n. 21
0
    if DIM == 2:
        domain = Rectangle(ORDER,
                           ceil(ne_z * width_x / depth),
                           ne_z,
                           l0=width_x,
                           l1=(-depth, 0),
                           diracPoints=src_locations,
                           diracTags=src_tags)
        #suppress the x-component on the x boundary
        q = whereZero(domain.getX()[0]) * [1, 0]
    else:
        domain = Brick(ORDER,
                       ceil(ne_z * width_x / depth),
                       ceil(ne_z * width_y / depth),
                       ne_z,
                       l0=width_x,
                       l1=width_y,
                       l2=(-depth, 0),
                       diracPoints=src_locations,
                       diracTags=src_tags)
        q = wherePositive(
            #suppress the x-component on the x boundary
            whereZero(domain.getX()[0]) * [1, 0, 0] +  #logical or
            #suppress the y-component on the y boundary at the source
            whereZero(domain.getX()[1]) * [0, 1, 0])

    # set up reciever locations
    locEW = Locator(domain, rcvEW_locations)
    tracerEW_x = SimpleSEGYWriter(receiver_group=rgEW,
                                  source=src_loc_2D,
                                  sampling_interval=sampling_interval,
Esempio n. 22
0
    def test_Brick_XY_system(self):
        ranks = getMPISizeWorld()
        for expanded in (True, False):
            for order in range(2, 11):
                dom = Brick(order, 3, 3 * ranks, 3, l0=6, l1=6, l2=6, d1=ranks)
                Y = Data(1, (3, ), Function(dom), expanded)
                X = Data(0, (3, 3), Function(dom), expanded)
                X[0, 0] = dom.getX()[0]
                X[1, 1] = dom.getX()[1]
                X[2, 2] = dom.getX()[2]

                f = Data(0, (3, ), Solution(dom), expanded)

                dom.addToRHS(f, [("Y", Y)],
                             dom.createAssembler("DefaultAssembler", []))
                dom.addToRHS(f, [("X", X)],
                             dom.createAssembler("DefaultAssembler", []))
                #nuke the boundary back to zero since it's not dealt with here
                for dim in range(3):
                    f *= whereNegative(dom.getX()[dim] - 6)
                res = Lsup(f)
                self.assertLess(
                    res, self.TOLERANCE,
                    ("assembly for {0}expanded order %d failed with %e >= %e" %
                     (order, res,
                      self.TOLERANCE)).format("" if expanded else "un-"))
Esempio n. 23
0
    def xtest_Brick_MPI_construction(self):
        for order in range(2, 11):
            dom = Brick(order,
                        2 * getMPISizeWorld(),
                        2,
                        2,
                        d0=getMPISizeWorld())
            self.assertEqual(
                Lsup(dom.getX()[0] + dom.getX()[1] + dom.getX()[2]), 3,
                "invalid Lsup(getX()) for x-split order %d" % order)
            X = interpolate(dom.getX()[0], Function(dom)) \
                    + interpolate(dom.getX()[1], Function(dom))
            val = Lsup(interpolate(X, ContinuousFunction(dom)) \
                    - (dom.getX()[0] + dom.getX()[1]))
            self.assertLess(
                val, 1e-10,
                "interpolation failure for x-split order %d" % order)

            dom = Brick(order,
                        2,
                        2 * getMPISizeWorld(),
                        2,
                        d1=getMPISizeWorld())
            self.assertEqual(
                Lsup(dom.getX()[0] + dom.getX()[1] + dom.getX()[2]), 3,
                "invalid Lsup(getX()) for y-split order %d" % order)
            X = interpolate(dom.getX()[0], Function(dom)) \
                    + interpolate(dom.getX()[1], Function(dom))
            val = Lsup(interpolate(X, ContinuousFunction(dom)) \
                    - (dom.getX()[0] + dom.getX()[1]))
            self.assertLess(
                val, 1e-10,
                "interpolation failure for y-split order %d" % order)

            dom = Brick(order,
                        2,
                        2,
                        2 * getMPISizeWorld(),
                        d2=getMPISizeWorld())
            self.assertEqual(
                Lsup(dom.getX()[0] + dom.getX()[1] + dom.getX()[2]), 3,
                "invalid Lsup(getX()) for z-split order %d" % order)
            X = interpolate(dom.getX()[0], Function(dom)) \
                    + interpolate(dom.getX()[1], Function(dom))
            val = Lsup(interpolate(X, ContinuousFunction(dom)) \
                    - (dom.getX()[0] + dom.getX()[1]))
            self.assertLess(
                val, 1e-10,
                "interpolation failure for z-split order %d" % order)
Esempio n. 24
0
    def test_Brick_MPI_construction(self):
        for order in range(2,11):
            dom = Brick(order, 2*getMPISizeWorld(), 2, 2, d0=getMPISizeWorld())
            self.assertEqual(Lsup(dom.getX()[0] + dom.getX()[1] + dom.getX()[2]),
                    3, "invalid Lsup(getX()) for x-split order %d"%order)
            X = interpolate(dom.getX()[0], Function(dom)) \
                    + interpolate(dom.getX()[1], Function(dom))
            val = Lsup(interpolate(X, ContinuousFunction(dom)) \
                    - (dom.getX()[0] + dom.getX()[1]))
            self.assertLess(val, 1e-10,
                    "interpolation failure for x-split order %d"%order)

            dom = Brick(order, 2, 2*getMPISizeWorld(), 2, d1=getMPISizeWorld())
            self.assertEqual(Lsup(dom.getX()[0] + dom.getX()[1] + dom.getX()[2]),
                    3, "invalid Lsup(getX()) for y-split order %d"%order)
            X = interpolate(dom.getX()[0], Function(dom)) \
                    + interpolate(dom.getX()[1], Function(dom))
            val = Lsup(interpolate(X, ContinuousFunction(dom)) \
                    - (dom.getX()[0] + dom.getX()[1]))
            self.assertLess(val, 1e-10,
                    "interpolation failure for y-split order %d"%order)
            
            dom = Brick(order, 2, 2, 2*getMPISizeWorld(), d2=getMPISizeWorld())
            self.assertEqual(Lsup(dom.getX()[0] + dom.getX()[1] + dom.getX()[2]),
                    3, "invalid Lsup(getX()) for z-split order %d"%order)
            X = interpolate(dom.getX()[0], Function(dom)) \
                    + interpolate(dom.getX()[1], Function(dom))
            val = Lsup(interpolate(X, ContinuousFunction(dom)) \
                    - (dom.getX()[0] + dom.getX()[1]))
            self.assertLess(val, 1e-10,
                    "interpolation failure for z-split order %d"%order)
    def test_Creation(self):
        r = self.numRanks
        el = self.numRanks * 3

        #test bad types
        with self.assertRaises(TypeError):
            Rectangle(2, 5, el, d1=r, diracPoints=(.0, 0.), diracTags=["test"])
        with self.assertRaises(TypeError):
            Rectangle(2,
                      5,
                      el,
                      d1=r,
                      diracPoints=[(.0, 0.)],
                      diracTags=("test"))
        with self.assertRaises(TypeError):
            Rectangle(2, 5, el, d1=r, diracPoints=[.0], diracTags=["test"])
        with self.assertRaises(TypeError):
            Rectangle(2, 5, el, d1=r, diracPoints=[.0, .0], diracTags=["test"])

        with self.assertRaises(TypeError):
            Brick(2,
                  5,
                  el,
                  5,
                  d1=r,
                  diracPoints=(.0, 0., 0.),
                  diracTags=["test"])
        with self.assertRaises(TypeError):
            Brick(2,
                  5,
                  el,
                  5,
                  d1=r,
                  diracPoints=[(.0, 0., 0.)],
                  diracTags=("test"))
        with self.assertRaises(TypeError):
            Brick(2, 5, el, 5, d1=r, diracPoints=[.0, 0.], diracTags=["test"])

        #test bad arg lengths
        with self.assertRaises(RuntimeError):
            Rectangle(2, 5, el, d1=r, diracPoints=[(.0, )], diracTags=["test"])
        with self.assertRaises(RuntimeError):
            Rectangle(2, 5, el, d1=r, diracPoints=[(.0, 1.)], diracTags=[])
        with self.assertRaises(RuntimeError):
            Rectangle(2,
                      5,
                      el,
                      d1=r,
                      diracPoints=[(.0, 0.)],
                      diracTags=["test", "break"])
        with self.assertRaises(RuntimeError):
            Rectangle(2,
                      5,
                      el,
                      d1=r,
                      diracPoints=[(.0, 0., 0.)],
                      diracTags=["test"])

        with self.assertRaises(RuntimeError):
            Brick(2,
                  5,
                  el,
                  5,
                  d1=r,
                  diracPoints=[(.0, 0., 0., 0.)],
                  diracTags=["test"])
        with self.assertRaises(RuntimeError):
            Brick(2,
                  5,
                  el,
                  5,
                  d1=r,
                  diracPoints=[(
                      .0,
                      0.,
                  )],
                  diracTags=["test"])
        with self.assertRaises(RuntimeError):
            Brick(2, 5, el, 5, d1=r, diracPoints=[(.0, )], diracTags=["test"])