def get_line_nodes(V): # Return the Line nodes for Q, DQ, RTCF/E, NCF/E from FIAT.reference_element import UFCInterval from FIAT import quadrature use_tensorproduct, N, ndim, sub_families, variant = tensor_product_space_query( V) assert use_tensorproduct cell = UFCInterval() if variant == "equispaced" and sub_families <= { "Q", "DQ", "Lagrange", "Discontinuous Lagrange" }: return [cell.make_points(1, 0, N + 1)] * ndim elif sub_families <= {"Q", "Lagrange"}: rule = quadrature.GaussLobattoLegendreQuadratureLineRule(cell, N + 1) return [rule.get_points()] * ndim elif sub_families <= {"DQ", "Discontinuous Lagrange"}: rule = quadrature.GaussLegendreQuadratureLineRule(cell, N + 1) return [rule.get_points()] * ndim elif sub_families < {"RTCF", "NCF"}: cg = quadrature.GaussLobattoLegendreQuadratureLineRule(cell, N + 1) dg = quadrature.GaussLegendreQuadratureLineRule(cell, N) return [cg.get_points()] + [dg.get_points()] * (ndim - 1) elif sub_families < {"RTCE", "NCE"}: cg = quadrature.GaussLobattoLegendreQuadratureLineRule(cell, N + 1) dg = quadrature.GaussLegendreQuadratureLineRule(cell, N) return [dg.get_points()] + [cg.get_points()] * (ndim - 1) else: raise ValueError("Don't know how to get line nodes for %s" % V.ufl_element())
def __init__(self, ref_el, degree): entity_ids = {0: {0: [], 1: []}, 1: {0: list(range(0, degree+1))}} lr = quadrature.GaussLegendreQuadratureLineRule(ref_el, degree+1) nodes = [functional.PointEvaluation(ref_el, x) for x in lr.pts] super().__init__(nodes, ref_el, entity_ids)
def __init__(self, ref_el, degree, order=1): bc_nodes = [] for x in ref_el.get_vertices(): bc_nodes.append([functional.PointEvaluation(ref_el, x), *[functional.PointDerivative(ref_el, x, [alpha]) for alpha in range(1, order)]]) bc_nodes[1].reverse() k = len(bc_nodes[0]) idof = slice(k, -k) bdof = list(range(-k, k)) bdof = bdof[k:] + bdof[:k] # Define the generalized eigenproblem on a GLL element gll = GaussLobattoLegendre(ref_el, degree) xhat = numpy.array([list(x.get_point_dict().keys())[0][0] for x in gll.dual_basis()]) # Tabulate the BC nodes constraints = gll.tabulate(order-1, ref_el.get_vertices()) C = numpy.column_stack(list(constraints.values())) perm = list(range(len(bdof))) perm = perm[::2] + perm[-1::-2] C = C[:, perm].T # Tabulate the basis that splits the DOFs into interior and bcs E = numpy.eye(gll.space_dimension()) E[bdof, idof] = -C[:, idof] E[bdof, :] = numpy.dot(numpy.linalg.inv(C[:, bdof]), E[bdof, :]) # Assemble the constrained Galerkin matrices on the reference cell rule = quadrature.GaussLegendreQuadratureLineRule(ref_el, degree+1) phi = gll.tabulate(order, rule.get_points()) E0 = numpy.dot(phi[(0, )].T, E) Ek = numpy.dot(phi[(order, )].T, E) B = numpy.dot(numpy.multiply(E0.T, rule.get_weights()), E0) A = numpy.dot(numpy.multiply(Ek.T, rule.get_weights()), Ek) # Eigenfunctions in the constrained basis S = numpy.eye(A.shape[0]) if S.shape[0] > len(bdof): _, Sii = sym_eig(A[idof, idof], B[idof, idof]) S[idof, idof] = Sii S[idof, bdof] = numpy.dot(Sii, numpy.dot(Sii.T, -B[idof, bdof])) # Eigenfunctions in the Lagrange basis S = numpy.dot(E, S) self.gll_points = xhat self.gll_tabulation = S.T # Interpolate eigenfunctions onto the quadrature points basis = numpy.dot(S.T, phi[(0, )]) nodes = bc_nodes[0] + [functional.IntegralMoment(ref_el, rule, f) for f in basis[idof]] + bc_nodes[1] entity_ids = {0: {0: [0], 1: [degree]}, 1: {0: list(range(1, degree))}} entity_permutations = {} entity_permutations[0] = {0: {0: [0]}, 1: {0: [0]}} entity_permutations[1] = {0: make_entity_permutations(1, degree - 1)} super(FDMDual, self).__init__(nodes, ref_el, entity_ids, entity_permutations)
def __init__(self, ref_el, degree): entity_ids = {0: {0: [], 1: []}, 1: {0: list(range(0, degree + 1))}} lr = quadrature.GaussLegendreQuadratureLineRule(ref_el, degree + 1) nodes = [functional.PointEvaluation(ref_el, x) for x in lr.pts] entity_permutations = {} entity_permutations[0] = {0: {0: []}, 1: {0: []}} entity_permutations[1] = {0: make_entity_permutations(1, degree + 1)} super(GaussLegendreDualSet, self).__init__(nodes, ref_el, entity_ids, entity_permutations)
def get_line_nodes(V): # Return the corresponding nodes in the Line for CG / DG from FIAT.reference_element import UFCInterval from FIAT import quadrature use_tensorproduct, N, family, variant = tensor_product_space_query(V) assert use_tensorproduct cell = UFCInterval() if variant == "equispaced": return cell.make_points(1, 0, N + 1) elif family <= {"Q", "Lagrange"}: rule = quadrature.GaussLobattoLegendreQuadratureLineRule(cell, N + 1) return rule.get_points() elif family <= {"DQ", "Discontinuous Lagrange"}: rule = quadrature.GaussLegendreQuadratureLineRule(cell, N + 1) return rule.get_points() else: raise ValueError("Don't know how to get line nodes for %r" % family)
def get_nodes_1d(V): # Return GLL nodes if V==CG or GL nodes if V==DG from FIAT import quadrature from FIAT.reference_element import DefaultLine use_tensorproduct, N, family, variant = tensor_product_space_query(V) assert use_tensorproduct if family <= {"Q", "Lagrange"}: if variant == "equispaced": nodes = np.linspace(-1.0E0, 1.0E0, N+1) else: rule = quadrature.GaussLobattoLegendreQuadratureLineRule(DefaultLine(), N+1) nodes = np.asarray(rule.get_points()).flatten() elif family <= {"DQ", "Discontinuous Lagrange"}: if variant == "equispaced": nodes = np.arange(1, N+2)*(2.0E0/(N+2))-1.0E0 else: rule = quadrature.GaussLegendreQuadratureLineRule(DefaultLine(), N+1) nodes = np.asarray(rule.get_points()).flatten() else: raise ValueError("Don't know how to get nodes for %r" % family) return nodes