def test_BrickInterpolation_ElementsToElements_FineToCoarse(self):
        mrd = MultiResolutionDomain(3, n0=2, n1=2*mpiSize, n2=3, d1=mpiSize, l0=2)
        d0 = mrd.getLevel(0)
        d1 = mrd.getLevel(1)
        d2 = mrd.getLevel(2)
        x0 = interpolate(d0.getX(), Function(d0))
        x1 = interpolate(d1.getX(), Function(d1))
        x2 = interpolate(d2.getX(), Function(d2))

        val = Lsup(x0 - interpolate(x1, Function(d0)))
        self.assertLess(val, 1e-12,
                "Interpolation failure from level 1 to level 0: %g !< 1e-12"%val)

        val = Lsup(x1 - interpolate(x2, Function(d1)))
        self.assertLess(val, 1e-12,
                "Interpolation failure from level 2 to level 1: %g !< 1e-12"%val)

        val = Lsup(x0 - interpolate(x2, Function(d0)))
        self.assertLess(val, 1e-12,
                "Interpolation failure from level 2 to level 0: %g !< 1e-12"%val)
        
        val = Lsup(integrate(interpolate(sin(x2[0]), Function(d0))*x0) - integrate(sin(x2[0])*x2))
        self.assertLess(val, 1e-12,
                "Interpolation failure: %g !< 1e-12"%val)

        val = integrate(interpolate(sin(x2[0]), Function(d0))*x0[0]*x0[1]*x0[2]) - integrate(sin(x2[0])*x2[0]*x2[1]*x2[2])
        self.assertLess(val, 1e-12,
                "Interpolation failure: %g !< 1e-12"%val)
        
        val = integrate(interpolate(sin(x2[0]), Function(d0))) - integrate(sin(x2[0]))
        self.assertLess(val, 1e-12,
                "Interpolation failure: %g !< 1e-12"%val)
    def test_BrickInterpolation_ElementsToElements_CoarseToFine(self):
        mrd = MultiResolutionDomain(3, n0=2, n1=2*mpiSize, n2=2, d1=mpiSize, l0=2)
        domains = [mrd.getLevel(i) for i in range(3)]
        X = [interpolate(i.getX(), Function(i)) for i in domains]

        for targetFS, name in [(Function, 'Function')]:
            for source_level in range(len(domains)):
                for target_level in range(source_level + 1, len(domains)):
                    val = Lsup(interpolate(X[target_level], targetFS(domains[target_level])) \
                            - interpolate(X[source_level], targetFS(domains[target_level])))
                    self.assertLess(val, 1e-12,
                            "Interpolation failure from %s level %d to %s level %d: %g !< 1e-12"%(\
                            'Function', source_level, name, target_level, val))
    def test_RectangleInterpolation_NodesToElements_FineToCoarse(self):
        mrd = MultiResolutionDomain(2, n0=2, n1=2*mpiSize-1, d1=mpiSize, l0=2)
        domains = [mrd.getLevel(i) for i in range(3)]
        X = [i.getX() for i in domains]

        for targetFS, name in [(Function, 'Function')]:
            for source_level in range(len(domains)):
                for target_level in range(0, source_level):
                    val = Lsup(interpolate(X[target_level], targetFS(domains[target_level])) \
                            - interpolate(X[source_level], targetFS(domains[target_level])))
                    self.assertLess(val, 1e-12,
                            "Interpolation failure from %s level %d to %s level %d: %g !< 1e-12"%(\
                            'ContinuousFunction', source_level, name, target_level, val))
    def test_RectangleInterpolation_ReducedToElements_CoarseToFine(self):
        mrd = MultiResolutionDomain(2, n0=2, n1=2*mpiSize-1, d1=mpiSize, l0=2)
        domains = [mrd.getLevel(i) for i in range(3)]
        X = [interpolate(i.getX(), ReducedFunction(i)) for i in domains]

        for targetFS, name in [(Function, 'Function')]:
            for source_level in range(len(domains)):
                for target_level in range(source_level + 1, len(domains)):
                    to = targetFS(domains[target_level])
                    desired = interpolate(X[source_level], Function(domains[source_level]))
                    val = Lsup(interpolate(X[source_level], to) - desired)
                    self.assertLess(val, 1e-12,
                            "Interpolation failure from %s level %d to %s level %d: %g !< 1e-12"%(\
                            'ReducedFunction', source_level, name, target_level, val))        
    def test_RectangleInterpolation_NodesToElements_FineToCoarse(self):
        mrd = MultiResolutionDomain(2,
                                    n0=2,
                                    n1=2 * mpiSize - 1,
                                    d1=mpiSize,
                                    l0=2)
        domains = [mrd.getLevel(i) for i in range(3)]
        X = [i.getX() for i in domains]

        for targetFS, name in [(Function, 'Function')]:
            for source_level in range(len(domains)):
                for target_level in range(0, source_level):
                    val = Lsup(interpolate(X[target_level], targetFS(domains[target_level])) \
                            - interpolate(X[source_level], targetFS(domains[target_level])))
                    self.assertLess(val, 1e-12,
                            "Interpolation failure from %s level %d to %s level %d: %g !< 1e-12"%(\
                            'ContinuousFunction', source_level, name, target_level, val))
    def test_BrickInterpolation_ElementsToElements_CoarseToFine(self):
        mrd = MultiResolutionDomain(3,
                                    n0=2,
                                    n1=2 * mpiSize,
                                    n2=2,
                                    d1=mpiSize,
                                    l0=2)
        domains = [mrd.getLevel(i) for i in range(3)]
        X = [interpolate(i.getX(), Function(i)) for i in domains]

        for targetFS, name in [(Function, 'Function')]:
            for source_level in range(len(domains)):
                for target_level in range(source_level + 1, len(domains)):
                    val = Lsup(interpolate(X[target_level], targetFS(domains[target_level])) \
                            - interpolate(X[source_level], targetFS(domains[target_level])))
                    self.assertLess(val, 1e-12,
                            "Interpolation failure from %s level %d to %s level %d: %g !< 1e-12"%(\
                            'Function', source_level, name, target_level, val))
    def test_RectangleInterpolation_ReducedToElements_CoarseToFine(self):
        mrd = MultiResolutionDomain(2,
                                    n0=2,
                                    n1=2 * mpiSize - 1,
                                    d1=mpiSize,
                                    l0=2)
        domains = [mrd.getLevel(i) for i in range(3)]
        X = [interpolate(i.getX(), ReducedFunction(i)) for i in domains]

        for targetFS, name in [(Function, 'Function')]:
            for source_level in range(len(domains)):
                for target_level in range(source_level + 1, len(domains)):
                    to = targetFS(domains[target_level])
                    desired = interpolate(X[source_level],
                                          Function(domains[source_level]))
                    val = Lsup(interpolate(X[source_level], to) - desired)
                    self.assertLess(val, 1e-12,
                            "Interpolation failure from %s level %d to %s level %d: %g !< 1e-12"%(\
                            'ReducedFunction', source_level, name, target_level, val))
    def test_BrickInterpolation_ElementsToElements_FineToCoarse(self):
        mrd = MultiResolutionDomain(3,
                                    n0=2,
                                    n1=2 * mpiSize,
                                    n2=3,
                                    d1=mpiSize,
                                    l0=2)
        d0 = mrd.getLevel(0)
        d1 = mrd.getLevel(1)
        d2 = mrd.getLevel(2)
        x0 = interpolate(d0.getX(), Function(d0))
        x1 = interpolate(d1.getX(), Function(d1))
        x2 = interpolate(d2.getX(), Function(d2))

        val = Lsup(x0 - interpolate(x1, Function(d0)))
        self.assertLess(
            val, 1e-12,
            "Interpolation failure from level 1 to level 0: %g !< 1e-12" % val)

        val = Lsup(x1 - interpolate(x2, Function(d1)))
        self.assertLess(
            val, 1e-12,
            "Interpolation failure from level 2 to level 1: %g !< 1e-12" % val)

        val = Lsup(x0 - interpolate(x2, Function(d0)))
        self.assertLess(
            val, 1e-12,
            "Interpolation failure from level 2 to level 0: %g !< 1e-12" % val)

        val = Lsup(
            integrate(interpolate(sin(x2[0]), Function(d0)) * x0) -
            integrate(sin(x2[0]) * x2))
        self.assertLess(val, 1e-12, "Interpolation failure: %g !< 1e-12" % val)

        val = integrate(
            interpolate(sin(x2[0]), Function(d0)) * x0[0] * x0[1] *
            x0[2]) - integrate(sin(x2[0]) * x2[0] * x2[1] * x2[2])
        self.assertLess(val, 1e-12, "Interpolation failure: %g !< 1e-12" % val)

        val = integrate(interpolate(sin(x2[0]), Function(d0))) - integrate(
            sin(x2[0]))
        self.assertLess(val, 1e-12, "Interpolation failure: %g !< 1e-12" % val)
def Brick(**kwargs):
    m = MultiResolutionDomain(3, **kwargs)
    return m.getLevel(1)
def Rectangle(**kwargs):
    m = MultiResolutionDomain(2, **kwargs)
    return m.getLevel(1)
def Brick(**kwargs):
    m = MultiResolutionDomain(3, **kwargs)
    return m.getLevel(1)
def Rectangle(**kwargs):
    m = MultiResolutionDomain(2, **kwargs)
    return m.getLevel(1)
def Brick(**kwargs):
    kwargs['n0'] //= 2
    kwargs['n1'] //= 2
    kwargs['n2'] //= 2
    m = MultiResolutionDomain(3, **kwargs)
    return m.getLevel(1)
def Rectangle(**kwargs):
    kwargs['n0'] //= 2
    kwargs['n1'] //= 2
    m = MultiResolutionDomain(2, **kwargs)
    return m.getLevel(1)
Beispiel #15
0
def Brick(**kwargs):
    kwargs['n0'] //= 2
    kwargs['n1'] //= 2
    kwargs['n2'] //= 2
    m = MultiResolutionDomain(3, **kwargs)
    return m.getLevel(1)
Beispiel #16
0
def Rectangle(**kwargs):
    kwargs['n0'] //= 2
    kwargs['n1'] //= 2
    m = MultiResolutionDomain(2, **kwargs)
    return m.getLevel(1)