Beispiel #1
0
    def eval_expected(self, x, y, **kwargs):
        r, th = cart_to_polar(x, y)

        if th < self.a/2:
            th += 2*np.pi

        return self.eval_expected_polar(r, th, **kwargs)
Beispiel #2
0
    def c1_test(self, plot=True):
        """
        Plot the reconstructed Neumann data, as approximated by a Chebyshev
        expansion. If the Chebyshev expansion shows "spikes" near the
        interfaces of the segments, something is probably wrong.
        """
        sample = self.get_boundary_sample()

        do_exact = hasattr(self.problem, 'eval_d_u_outwards')

        s_data = np.zeros(len(sample))
        expansion_data = np.zeros(len(sample))

        if do_exact:
            exact_data = np.zeros(len(sample))

        for l in range(len(sample)):
            p = sample[l]
            s_data[l] = p['s']

            if do_exact:
                exact_data[l] = self.problem.eval_d_u_outwards(p['arg'], p['sid']).real

            r, th = domain_util.cart_to_polar(p['x'], p['y'])
            sid = domain_util.get_sid(self.a, th)

            if sid == 0:
                arg = th
            else:
                arg = r

            for JJ in range(len(self.B_desc)):
                expansion_data[l] +=\
                    (self.c1[JJ] *
                    self.eval_dn_B_arg(0, JJ, arg, sid)).real

        import matplotlib.pyplot as plt

        if do_exact:
            error = np.max(np.abs(exact_data - expansion_data))
            print('c1 error: {}'.format(error))

            plt.plot(s_data, exact_data, linewidth=5, color='#BBBBBB', label='Exact')

        if not plot:
            return

        plt.plot(s_data, expansion_data, label='Expansion')
        plt.legend(loc=2)
        #plt.ylim(-1.5, 1.5)
        plt.title('c1')
        plt.xlabel('Arclength s')
        plt.ylabel('Reconstructed Neumann data')
        plt.show()
Beispiel #3
0
    def do_extend_2_standard(self, i, j, **kwargs):
        x, y = self.get_coord(i, j)
        x0, y0 = self.get_radius_point(2, x, y)

        param_r = cart_to_polar(x0, y0)[0]

        deriv_types = (
            (0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (4, 0),
        )
        derivs = self.ext_calc_xi_derivs(deriv_types, param_r, 2, **kwargs)
        n = self.signed_dist_to_radius(2, x, y)

        value = self.extend_radius(n=n, **derivs)

        return {'elen': abs(n), 'value': value}
Beispiel #4
0
    def _calc_inhomo_radius(self, x0, y0, x1, y1, tan, n):
        p = self.problem
        f = p.eval_f(x0, y0)

        if x0 == 0 and y0 == 0:
            """
            Use Taylor's theorem to construct a smooth extension of
            grad_f, and hessian_f at the origin, since they may
            be undefined or annoying to calculate at this point.
            """
            h = self.AD_len / (10 * self.N)

            hessian_f = p.eval_hessian_f(-h, 0)

            grad_f = p.eval_grad_f(-h, 0)
            grad_f += h * hessian_f.dot((1, 0))
        else:
            grad_f = p.eval_grad_f(x0, y0)
            hessian_f = p.eval_hessian_f(x0, y0)

        vec = np.array((x1 - x0, y1 - y0))

        if np.linalg.norm(vec) != 0:
            vec /= np.linalg.norm(vec)

        d_f_n = grad_f.dot(vec) * np.sign(n)
        d2_f_n = hessian_f.dot(vec).dot(vec)

        d2_f_s = hessian_f.dot(tan).dot(tan)

        elen = abs(n)

        # Only so that elen matches that of the homogeneous extension
        r, th = cart_to_polar(x0, y0)
        if x0 < 0 or r > self.R:
            elen += r

        v = self.inhomo_extend_arbitrary(n=n, f=f, d_f_n=d_f_n, d2_f_n=d2_f_n, d2_f_s=d2_f_s, curv=0)

        return {"elen": elen, "value": v}
Beispiel #5
0
    def c0_test(self, plot=True):
        """
        Plot the Dirichlet data along with its Chebyshev expansion. If there
        is more than a minor difference between the two, something is wrong.
        """
        k = self.k
        a = self.a
        nu = self.nu

        sample = self.get_boundary_sample()

        s_data = np.zeros(len(sample))
        exact_data = np.zeros(len(sample))
        expansion_data = np.zeros(len(sample))

        exact_data_outer = []
        expansion_data_outer = []

        for l in range(len(sample)):
            p = sample[l]
            s_data[l] = p['s']

            r, th = domain_util.cart_to_polar(p['x'], p['y'])
            sid = domain_util.get_sid(self.a, th)

            exact_data[l] = self.problem.eval_bc(p['arg'], sid).real

            if sid == 0:
                arg = th
            else:
                arg = r

            for JJ in range(len(self.B_desc)):
                expansion_data[l] +=\
                    (self.c0[JJ] *
                    self.eval_dn_B_arg(0, JJ, arg, sid)).real

            if sid == 0:
                exact_data_outer.append(exact_data[l])
                expansion_data_outer.append(expansion_data[l])

        exact_data_outer = np.array(exact_data_outer)
        expansion_data_outer = np.array(expansion_data_outer)
        print('c0 error outer:', np.max(np.abs(exact_data_outer - expansion_data_outer)))

        print('c0 error:', np.max(np.abs(exact_data - expansion_data)))




        #for l in range(len(exact_data)):
        #    diff = abs(exact_data[l] - expansion_data[l])
        #    if diff > .06:
        #        print(sample[l], 'diff:', diff)

        if not plot:
            return

        import matplotlib.pyplot as plt

        plt.plot(s_data, exact_data, linewidth=5, color='#BBBBBB', label='Exact')
        plt.plot(s_data, expansion_data, label='Expansion')

        plt.legend(loc=0)
        plt.title('c0')
        plt.xlabel('Arclength s')
        plt.ylabel('Dirichlet data')
        plt.show()
Beispiel #6
0
    def eval_f(self, x, y):
        if self.homogeneous:
            return 0

        return self.eval_f_polar(*cart_to_polar(x, y))
Beispiel #7
0
 def get_polar(self, i, j):
     """
     Get the polar coordinates of grid point (i,j)
     """
     x, y = self.get_coord(i, j)
     return cart_to_polar(x, y)
Beispiel #8
0
 def eval_grad_f(self, x, y):
     """
     Evaluate gradient of f at (x, y), using the chain rule. Returns the
     result as a NumPy array.
     """
     return self.eval_grad_f_polar(*cart_to_polar(x, y))
Beispiel #9
0
 def eval_hessian_f(self, x, y):
     """
     Evaluate the Cartesian Hessian of f at (x, y), using the chain rule.
     Returns the result as a 2x2 NumPy array.
     """
     return self.eval_hessian_f_polar(*cart_to_polar(x, y))