From 657321796eeda75085e49048cc759f70d587cc5b Mon Sep 17 00:00:00 2001 From: India Marsden Date: Mon, 19 Aug 2024 13:12:40 +0100 Subject: [PATCH 01/20] First draft of expanding set size to match when unioning --- FIAT/polynomial_set.py | 38 +++++++++++++++++++++++++++++++++++++- 1 file changed, 37 insertions(+), 1 deletion(-) diff --git a/FIAT/polynomial_set.py b/FIAT/polynomial_set.py index 732d03892..a3232eba1 100644 --- a/FIAT/polynomial_set.py +++ b/FIAT/polynomial_set.py @@ -169,7 +169,9 @@ def polynomial_set_union_normalized(A, B): not contain any of the same members of the set, as we construct a span via SVD. """ - new_coeffs = numpy.array(list(A.coeffs) + list(B.coeffs)) + # new_coeffs = numpy.array(list(A.coeffs) + list(B.coeffs)) + assert A.get_reference_element() == B.get_reference_element() + new_coeffs = construct_new_coeffs(A.get_reference_element(), A, B) func_shape = new_coeffs.shape[1:] if len(func_shape) == 1: (u, sig, vt) = numpy.linalg.svd(new_coeffs) @@ -192,6 +194,40 @@ def polynomial_set_union_normalized(A, B): coeffs) +def construct_new_coeffs(ref_el, A, B): + # Constructs new coefficients for the set union of A and B + # If A and B do not have the same degree the smaller one + # is extended to match the larger + + sd = ref_el.get_spatial_dimension() + if A.degree != B.degree: + higher = A if A.degree > B.degree else B + lower = B if A.degree > B.degree else A + + dimHigher = expansions.polynomial_dimension(ref_el, higher.degree) + dimLower = expansions.polynomial_dimension(ref_el, lower.degree) + + if (dimLower == len(list(lower.coeffs))): + lower_indices = list(chain(*(range(i * dimHigher, i * dimHigher + dimLower) for i in range(sd)))) + embedded = higher.take(lower_indices) + embedded_coeffs = embedded.coeffs + else: + # if lower space not complete take a different approach + embedded_coeffs = [] + diff = dimHigher - dimLower + for coeff in lower.coeffs: + new_coeff = [] + for row in coeff: + new_coeff.append(numpy.append(row, [0 for i in range(diff)])) + embedded_coeffs.append(new_coeff) + + new_coeffs = numpy.array(list(embedded_coeffs) + list(higher.coeffs)) + else: + new_coeffs = numpy.array(list(A.coeffs) + list(B.coeffs)) + + return new_coeffs + + class ONSymTensorPolynomialSet(PolynomialSet): """Constructs an orthonormal basis for symmetric-tensor-valued polynomials on a reference element. From dc5188a822e684c9466111645dcf7ca1fd9d1dc7 Mon Sep 17 00:00:00 2001 From: India Marsden Date: Mon, 19 Aug 2024 14:06:49 +0100 Subject: [PATCH 02/20] Change condition of extension --- FIAT/polynomial_set.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/FIAT/polynomial_set.py b/FIAT/polynomial_set.py index a3232eba1..0b64c3cf7 100644 --- a/FIAT/polynomial_set.py +++ b/FIAT/polynomial_set.py @@ -200,7 +200,7 @@ def construct_new_coeffs(ref_el, A, B): # is extended to match the larger sd = ref_el.get_spatial_dimension() - if A.degree != B.degree: + if A.get_embedded_degree() != B.get_embedded_degree(): higher = A if A.degree > B.degree else B lower = B if A.degree > B.degree else A From c75efef8dc904005213ece3877a9f04835d3ec0e Mon Sep 17 00:00:00 2001 From: India Marsden Date: Tue, 20 Aug 2024 14:53:13 +0100 Subject: [PATCH 03/20] Adapt new coeff construction for vec sets --- FIAT/polynomial_set.py | 29 +++++++++++++++++------------ 1 file changed, 17 insertions(+), 12 deletions(-) diff --git a/FIAT/polynomial_set.py b/FIAT/polynomial_set.py index 0b64c3cf7..27292c171 100644 --- a/FIAT/polynomial_set.py +++ b/FIAT/polynomial_set.py @@ -204,23 +204,28 @@ def construct_new_coeffs(ref_el, A, B): higher = A if A.degree > B.degree else B lower = B if A.degree > B.degree else A - dimHigher = expansions.polynomial_dimension(ref_el, higher.degree) - dimLower = expansions.polynomial_dimension(ref_el, lower.degree) - - if (dimLower == len(list(lower.coeffs))): - lower_indices = list(chain(*(range(i * dimHigher, i * dimHigher + dimLower) for i in range(sd)))) - embedded = higher.take(lower_indices) - embedded_coeffs = embedded.coeffs - else: - # if lower space not complete take a different approach - embedded_coeffs = [] - diff = dimHigher - dimLower - for coeff in lower.coeffs: + # dimHigher = expansions.polynomial_dimension(ref_el, higher.degree) + # dimLower = expansions.polynomial_dimension(ref_el, lower.degree) + + try: + sd = lower.get_shape()[0] + except IndexError: + sd = 1 + embedded_coeffs = [] + diff = higher.coeffs.shape[-1] - lower.coeffs.shape[-1] + for coeff in lower.coeffs: + if sd > 1: new_coeff = [] for row in coeff: new_coeff.append(numpy.append(row, [0 for i in range(diff)])) embedded_coeffs.append(new_coeff) + else: + embedded_coeffs.append(numpy.append(coeff, [0 for i in range(diff)])) + embedded_coeffs = numpy.array(embedded_coeffs) + # print("embedded", embedded_coeffs.shape) + # print("higher", higher.coeffs.shape) + # print("lower", lower.coeffs.shape) new_coeffs = numpy.array(list(embedded_coeffs) + list(higher.coeffs)) else: new_coeffs = numpy.array(list(A.coeffs) + list(B.coeffs)) From dfd13475368d1ca3d935494747bbda6503f78961 Mon Sep 17 00:00:00 2001 From: India Marsden Date: Wed, 21 Aug 2024 12:02:48 +0100 Subject: [PATCH 04/20] select larger of degrees --- FIAT/polynomial_set.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/FIAT/polynomial_set.py b/FIAT/polynomial_set.py index 27292c171..7553007dc 100644 --- a/FIAT/polynomial_set.py +++ b/FIAT/polynomial_set.py @@ -187,9 +187,11 @@ def polynomial_set_union_normalized(A, B): coeffs = numpy.reshape(vt[:num_sv], (num_sv,) + func_shape) + deg = max(A.get_degree(), B.get_degree()) + em_deg = max(A.get_embedded_degree(), B.get_embedded_degree()) return PolynomialSet(A.get_reference_element(), - A.get_degree(), - A.get_embedded_degree(), + deg, + em_deg, A.get_expansion_set(), coeffs) @@ -223,9 +225,6 @@ def construct_new_coeffs(ref_el, A, B): embedded_coeffs.append(numpy.append(coeff, [0 for i in range(diff)])) embedded_coeffs = numpy.array(embedded_coeffs) - # print("embedded", embedded_coeffs.shape) - # print("higher", higher.coeffs.shape) - # print("lower", lower.coeffs.shape) new_coeffs = numpy.array(list(embedded_coeffs) + list(higher.coeffs)) else: new_coeffs = numpy.array(list(A.coeffs) + list(B.coeffs)) From 21f1bf163a0ac185075d79da19ec4729c3a8a2b8 Mon Sep 17 00:00:00 2001 From: India Marsden Date: Wed, 28 Aug 2024 14:35:07 +0100 Subject: [PATCH 05/20] Add orthonormal requirement --- FIAT/expansions.py | 2 +- FIAT/nedelec.py | 8 ++++---- FIAT/polynomial_set.py | 10 ++++------ FIAT/raviart_thomas.py | 6 +++--- 4 files changed, 12 insertions(+), 14 deletions(-) diff --git a/FIAT/expansions.py b/FIAT/expansions.py index bf38f9795..bf2015b18 100644 --- a/FIAT/expansions.py +++ b/FIAT/expansions.py @@ -327,7 +327,7 @@ def _tabulate_on_cell(self, n, pts, order=0, cell=0, direction=None): sd = self.ref_el.get_spatial_dimension() # Always return 1 for n=0 to make regression tests pass - scale = 1.0 if n == 0 and len(self.affine_mappings) == 1 else self.get_scale(cell=cell) + scale = 1.0 if n == 0 and (self.scale is None) else self.get_scale(cell=cell) phi = dubiner_recurrence(sd, n, lorder, ref_pts, Jinv, scale, variant=self.variant) if self.continuity == "C0": diff --git a/FIAT/nedelec.py b/FIAT/nedelec.py index c05133022..ca135074c 100644 --- a/FIAT/nedelec.py +++ b/FIAT/nedelec.py @@ -22,7 +22,7 @@ def NedelecSpace2D(ref_el, degree): raise Exception("NedelecSpace2D requires 2d reference element") k = degree - 1 - vec_Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1, (sd,)) + vec_Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1, (sd,), scale="orthonormal") dimPkp1 = expansions.polynomial_dimension(ref_el, k + 1) dimPk = expansions.polynomial_dimension(ref_el, k) @@ -32,7 +32,7 @@ def NedelecSpace2D(ref_el, degree): for i in range(sd)))) vec_Pk_from_Pkp1 = vec_Pkp1.take(vec_Pk_indices) - Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1) + Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1, scale="orthonormal") PkH = Pkp1.take(list(range(dimPkm1, dimPk))) Q = create_quadrature(ref_el, 2 * (k + 1)) @@ -43,8 +43,8 @@ def NedelecSpace2D(ref_el, degree): CrossX = numpy.dot(numpy.array([[0.0, 1.0], [-1.0, 0.0]]), Qpts.T) PkHCrossX_at_Qpts = PkH_at_Qpts[:, None, :] * CrossX[None, :, :] - PkHCrossX_coeffs = numpy.dot(numpy.multiply(PkHCrossX_at_Qpts, Qwts), Pkp1_at_Qpts.T) - + PkHCrossX_coeffs = numpy.dot(numpy.multiply(PkHCrossX_at_Qpts, Qwts), + Pkp1_at_Qpts.T) PkHcrossX = polynomial_set.PolynomialSet(ref_el, k + 1, k + 1, diff --git a/FIAT/polynomial_set.py b/FIAT/polynomial_set.py index 7553007dc..4fb7720ac 100644 --- a/FIAT/polynomial_set.py +++ b/FIAT/polynomial_set.py @@ -169,10 +169,10 @@ def polynomial_set_union_normalized(A, B): not contain any of the same members of the set, as we construct a span via SVD. """ - # new_coeffs = numpy.array(list(A.coeffs) + list(B.coeffs)) assert A.get_reference_element() == B.get_reference_element() new_coeffs = construct_new_coeffs(A.get_reference_element(), A, B) func_shape = new_coeffs.shape[1:] + if len(func_shape) == 1: (u, sig, vt) = numpy.linalg.svd(new_coeffs) num_sv = len([s for s in sig if abs(s) > 1.e-10]) @@ -182,7 +182,9 @@ def polynomial_set_union_normalized(A, B): new_shape1 = numpy.prod(func_shape) newshape = (new_shape0, new_shape1) nc = numpy.reshape(new_coeffs, newshape) + (u, sig, vt) = numpy.linalg.svd(nc, 1) + num_sv = len([s for s in sig if abs(s) > 1.e-10]) coeffs = numpy.reshape(vt[:num_sv], (num_sv,) + func_shape) @@ -206,13 +208,11 @@ def construct_new_coeffs(ref_el, A, B): higher = A if A.degree > B.degree else B lower = B if A.degree > B.degree else A - # dimHigher = expansions.polynomial_dimension(ref_el, higher.degree) - # dimLower = expansions.polynomial_dimension(ref_el, lower.degree) - try: sd = lower.get_shape()[0] except IndexError: sd = 1 + embedded_coeffs = [] diff = higher.coeffs.shape[-1] - lower.coeffs.shape[-1] for coeff in lower.coeffs: @@ -224,11 +224,9 @@ def construct_new_coeffs(ref_el, A, B): else: embedded_coeffs.append(numpy.append(coeff, [0 for i in range(diff)])) embedded_coeffs = numpy.array(embedded_coeffs) - new_coeffs = numpy.array(list(embedded_coeffs) + list(higher.coeffs)) else: new_coeffs = numpy.array(list(A.coeffs) + list(B.coeffs)) - return new_coeffs diff --git a/FIAT/raviart_thomas.py b/FIAT/raviart_thomas.py index f33ce937f..13de2e46f 100644 --- a/FIAT/raviart_thomas.py +++ b/FIAT/raviart_thomas.py @@ -20,7 +20,7 @@ def RTSpace(ref_el, degree): sd = ref_el.get_spatial_dimension() k = degree - 1 - vec_Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1, (sd,)) + vec_Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1, (sd,), scale="orthonormal") dimPkp1 = expansions.polynomial_dimension(ref_el, k + 1) dimPk = expansions.polynomial_dimension(ref_el, k) @@ -30,7 +30,7 @@ def RTSpace(ref_el, degree): for i in range(sd)))) vec_Pk_from_Pkp1 = vec_Pkp1.take(vec_Pk_indices) - Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1) + Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1, scale="orthonormal") PkH = Pkp1.take(list(range(dimPkm1, dimPk))) Q = create_quadrature(ref_el, 2 * (k + 1)) @@ -39,12 +39,12 @@ def RTSpace(ref_el, degree): # have to work on this through "tabulate" interface # first, tabulate PkH at quadrature points PkH_at_Qpts = PkH.tabulate(Qpts)[(0,) * sd] + Pkp1_at_Qpts = Pkp1.tabulate(Qpts)[(0,) * sd] x = Qpts.T PkHx_at_Qpts = PkH_at_Qpts[:, None, :] * x[None, :, :] PkHx_coeffs = numpy.dot(numpy.multiply(PkHx_at_Qpts, Qwts), Pkp1_at_Qpts.T) - PkHx = polynomial_set.PolynomialSet(ref_el, k, k + 1, From 2b45bd575f08eb91b8b0a7d230a8d839033a8d54 Mon Sep 17 00:00:00 2001 From: India Marsden Date: Mon, 9 Dec 2024 11:05:25 +0000 Subject: [PATCH 06/20] Move finat commits from old branch --- finat/__init__.py | 1 + finat/fiat_elements.py | 5 +++++ 2 files changed, 6 insertions(+) diff --git a/finat/__init__.py b/finat/__init__.py index cad018212..4b71639a4 100644 --- a/finat/__init__.py +++ b/finat/__init__.py @@ -12,6 +12,7 @@ from .fiat_elements import GopalakrishnanLedererSchoberlSecondKind # noqa: F401 from .fiat_elements import FacetBubble # noqa: F401 from .fiat_elements import KongMulderVeldhuizen # noqa: F401 +from .fiat_elements import IndiaDefElement #noqa: F401 from .argyris import Argyris # noqa: F401 from .aw import ArnoldWinther # noqa: F401 diff --git a/finat/fiat_elements.py b/finat/fiat_elements.py index 1f2081894..5876a2da9 100644 --- a/finat/fiat_elements.py +++ b/finat/fiat_elements.py @@ -480,3 +480,8 @@ def __init__(self, cell, degree, variant=None): class NedelecSecondKind(VectorFiatElement): def __init__(self, cell, degree, variant=None): super().__init__(FIAT.NedelecSecondKind(cell, degree, variant=variant)) + + +class IndiaDefElement(FiatElement): + def __init__(self, triple): + super(IndiaDefElement, self).__init__(triple.to_fiat_elem()) From 9b0568841ff51606bb52c9041f686bbc24a60ebf Mon Sep 17 00:00:00 2001 From: India Marsden Date: Mon, 9 Dec 2024 11:06:11 +0000 Subject: [PATCH 07/20] Lint --- finat/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/finat/__init__.py b/finat/__init__.py index 4b71639a4..7e70161a4 100644 --- a/finat/__init__.py +++ b/finat/__init__.py @@ -12,7 +12,7 @@ from .fiat_elements import GopalakrishnanLedererSchoberlSecondKind # noqa: F401 from .fiat_elements import FacetBubble # noqa: F401 from .fiat_elements import KongMulderVeldhuizen # noqa: F401 -from .fiat_elements import IndiaDefElement #noqa: F401 +from .fiat_elements import IndiaDefElement # noqa: F401 from .argyris import Argyris # noqa: F401 from .aw import ArnoldWinther # noqa: F401 From 8d1a0747402b9734807bb35420630e59f4f0aa63 Mon Sep 17 00:00:00 2001 From: India Marsden Date: Mon, 6 Jan 2025 13:31:27 +0000 Subject: [PATCH 08/20] Refactor to deal with single source of truth --- finat/element_factory.py | 8 ++++++++ finat/ufl/__init__.py | 1 + finat/ufl/fuseelement.py | 42 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 51 insertions(+) create mode 100644 finat/ufl/fuseelement.py diff --git a/finat/element_factory.py b/finat/element_factory.py index 48db428d8..eead428ee 100644 --- a/finat/element_factory.py +++ b/finat/element_factory.py @@ -24,6 +24,7 @@ import finat import finat.ufl +from redefining_fe.cells import CellComplexToUFL as FuseCell import ufl from FIAT import ufc_cell @@ -112,6 +113,8 @@ def as_fiat_cell(cell): :arg cell: the :class:`ufl.Cell` to convert.""" if not isinstance(cell, ufl.AbstractCell): raise ValueError("Expecting a UFL Cell") + if isinstance(cell, FuseCell): + return cell.to_fiat() return ufc_cell(cell) @@ -302,6 +305,11 @@ def convert_restrictedelement(element, **kwargs): return finat.RestrictedElement(finat_elem, element.restriction_domain()), deps +@convert.register(finat.ufl.FuseElement) +def convert_india_def(element, **kwargs): + return finat.fiat_elements.IndiaDefElement(element.triple), set() + + hexahedron_tpc = ufl.TensorProductCell(ufl.interval, ufl.interval, ufl.interval) quadrilateral_tpc = ufl.TensorProductCell(ufl.interval, ufl.interval) _cache = weakref.WeakKeyDictionary() diff --git a/finat/ufl/__init__.py b/finat/ufl/__init__.py index 21a7d13d1..33373eb59 100644 --- a/finat/ufl/__init__.py +++ b/finat/ufl/__init__.py @@ -19,3 +19,4 @@ from finat.ufl.mixedelement import MixedElement, TensorElement, VectorElement # noqa: F401 from finat.ufl.restrictedelement import RestrictedElement # noqa: F401 from finat.ufl.tensorproductelement import TensorProductElement # noqa: F401 +from finat.ufl.fuseelement import FuseElement # noqa: F401 \ No newline at end of file diff --git a/finat/ufl/fuseelement.py b/finat/ufl/fuseelement.py new file mode 100644 index 000000000..8b75fc676 --- /dev/null +++ b/finat/ufl/fuseelement.py @@ -0,0 +1,42 @@ +"""Element.""" +# -*- coding: utf-8 -*- +# Copyright (C) 2025 India Marsden +# +# SPDX-License-Identifier: LGPL-3.0-or-later + +from finat.ufl.finiteelementbase import FiniteElementBase + +class FuseElement(FiniteElementBase): + """ + TODO: Need to deal with cases where value shape and reference value shape are different + """ + + def __init__(self, triple, cell=None): + self.triple = triple + if not cell: + cell = self.triple.cell.to_ufl() + + # this isn't really correct + degree = self.triple.spaces[0].degree() + super(FuseElement, self).__init__("IT", cell, degree, None, triple.get_value_shape()) + + def __repr__(self): + return "FiniteElement(%s, %s, (%s, %s, %s), %s)" % ( + repr(self.triple.DOFGenerator), repr(self.triple.cell), repr(self.triple.spaces[0]), repr(self.triple.spaces[1]), repr(self.triple.spaces[2]), "X") + + def __str__(self): + return "" % (self.triple.spaces[0], self.triple.cell) + + def mapping(self): + if str(self.sobolev_space) == "HCurl": + return "covariant Piola" + elif str(self.sobolev_space) == "HDiv": + return "contravariant Piola" + else: + return "identity" + + def sobolev_space(self): + return self.triple.spaces[1] + + def reconstruct(self, family=None, cell=None, degree=None, quad_scheme=None, variant=None): + return FuseElement(self.triple, cell=cell) From b72cd61da8b735ed14af0b2ed96d59c2c621266b Mon Sep 17 00:00:00 2001 From: India Marsden Date: Mon, 6 Jan 2025 15:49:12 +0000 Subject: [PATCH 09/20] Refactoring --- finat/fiat_elements.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/finat/fiat_elements.py b/finat/fiat_elements.py index 04e25089b..4ac4aa7ba 100644 --- a/finat/fiat_elements.py +++ b/finat/fiat_elements.py @@ -484,4 +484,4 @@ def __init__(self, cell, degree, variant=None): class IndiaDefElement(FiatElement): def __init__(self, triple): - super(IndiaDefElement, self).__init__(triple.to_fiat_elem()) + super(IndiaDefElement, self).__init__(triple.to_fiat()) From a89d057d51f6ea382182a1e2e1676b684c3803a7 Mon Sep 17 00:00:00 2001 From: India Marsden <37078108+indiamai@users.noreply.github.com> Date: Fri, 10 Jan 2025 11:17:20 +0000 Subject: [PATCH 10/20] Renaming fuse project (#125) Renaming + adding to install --- finat/element_factory.py | 2 +- finat/ufl/__init__.py | 2 +- finat/ufl/fuseelement.py | 3 +++ pyproject.toml | 1 + 4 files changed, 6 insertions(+), 2 deletions(-) diff --git a/finat/element_factory.py b/finat/element_factory.py index eead428ee..5adcca5f9 100644 --- a/finat/element_factory.py +++ b/finat/element_factory.py @@ -24,7 +24,7 @@ import finat import finat.ufl -from redefining_fe.cells import CellComplexToUFL as FuseCell +from fuse.cells import CellComplexToUFL as FuseCell import ufl from FIAT import ufc_cell diff --git a/finat/ufl/__init__.py b/finat/ufl/__init__.py index 33373eb59..fd656db6e 100644 --- a/finat/ufl/__init__.py +++ b/finat/ufl/__init__.py @@ -19,4 +19,4 @@ from finat.ufl.mixedelement import MixedElement, TensorElement, VectorElement # noqa: F401 from finat.ufl.restrictedelement import RestrictedElement # noqa: F401 from finat.ufl.tensorproductelement import TensorProductElement # noqa: F401 -from finat.ufl.fuseelement import FuseElement # noqa: F401 \ No newline at end of file +from finat.ufl.fuseelement import FuseElement # noqa: F401 diff --git a/finat/ufl/fuseelement.py b/finat/ufl/fuseelement.py index 8b75fc676..b83b26ba0 100644 --- a/finat/ufl/fuseelement.py +++ b/finat/ufl/fuseelement.py @@ -6,8 +6,11 @@ from finat.ufl.finiteelementbase import FiniteElementBase + class FuseElement(FiniteElementBase): """ + A finite element defined using FUSE. + TODO: Need to deal with cases where value shape and reference value shape are different """ diff --git a/pyproject.toml b/pyproject.toml index c224c1fbe..2d43b6dc5 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -12,6 +12,7 @@ dependencies = [ "symengine", "sympy", "fenics-ufl @ git+https://github.com/firedrakeproject/ufl.git", + "fuse-element @ git+https://github.com/indiamai/fuse.git", ] requires-python = ">=3.10" authors = [ From ac81474f539c09adaca0b520325c68e37cf6f3fa Mon Sep 17 00:00:00 2001 From: India Marsden Date: Sat, 11 Jan 2025 11:54:04 +0000 Subject: [PATCH 11/20] Address Pablo's comments --- FIAT/polynomial_set.py | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/FIAT/polynomial_set.py b/FIAT/polynomial_set.py index ce90dca14..7a1df1013 100644 --- a/FIAT/polynomial_set.py +++ b/FIAT/polynomial_set.py @@ -190,12 +190,18 @@ def polynomial_set_union_normalized(A, B): def construct_new_coeffs(ref_el, A, B): - # Constructs new coefficients for the set union of A and B - # If A and B do not have the same degree the smaller one - # is extended to match the larger + """ + Constructs new coefficients for the set union of A and B + If A and B are discontinuous and do not have the same degree the smaller one + is extended to match the larger. + + This does not handle the case that A and B have continuity but not the same degree. + """ sd = ref_el.get_spatial_dimension() - if A.get_embedded_degree() != B.get_embedded_degree(): + if A.get_expansion_set().continuity != B.get_expansion_set().continuity: + raise ValueError("Continuity of expansion sets does not match.") + if A.get_embedded_degree() != B.get_embedded_degree() and A.get_expansion_set().continuity is None: higher = A if A.degree > B.degree else B lower = B if A.degree > B.degree else A @@ -215,9 +221,9 @@ def construct_new_coeffs(ref_el, A, B): else: embedded_coeffs.append(numpy.append(coeff, [0 for i in range(diff)])) embedded_coeffs = numpy.array(embedded_coeffs) - new_coeffs = numpy.array(list(embedded_coeffs) + list(higher.coeffs)) + new_coeffs = numpy.concatenate((embedded_coeffs, higher.coeffs), axis=0) else: - new_coeffs = numpy.array(list(A.coeffs) + list(B.coeffs)) + new_coeffs = numpy.concatenate((A.coeffs, B.coeffs), axis=0) return new_coeffs From 9420a6dbe6e94a10ed89aec50ffef6e9077e144b Mon Sep 17 00:00:00 2001 From: India Marsden Date: Sat, 11 Jan 2025 11:55:20 +0000 Subject: [PATCH 12/20] Lint --- FIAT/polynomial_set.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/FIAT/polynomial_set.py b/FIAT/polynomial_set.py index 7a1df1013..4f61968bd 100644 --- a/FIAT/polynomial_set.py +++ b/FIAT/polynomial_set.py @@ -194,7 +194,7 @@ def construct_new_coeffs(ref_el, A, B): Constructs new coefficients for the set union of A and B If A and B are discontinuous and do not have the same degree the smaller one is extended to match the larger. - + This does not handle the case that A and B have continuity but not the same degree. """ From be81de3f9297ac0b45390ba4ae4c9da4e58af2c7 Mon Sep 17 00:00:00 2001 From: India Marsden Date: Sat, 11 Jan 2025 12:04:42 +0000 Subject: [PATCH 13/20] Remove final references to India Def --- finat/__init__.py | 2 +- finat/element_factory.py | 4 ++-- finat/fiat_elements.py | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/finat/__init__.py b/finat/__init__.py index c02fc90d6..4183d2d3f 100644 --- a/finat/__init__.py +++ b/finat/__init__.py @@ -8,7 +8,7 @@ TrimmedSerendipityCurl, TrimmedSerendipityDiv, # noqa: F401 TrimmedSerendipityEdge, TrimmedSerendipityFace, # noqa: F401 Nedelec, NedelecSecondKind, RaviartThomas, Regge, # noqa: F401 - IndiaDefElement) # noqa: F401 + FuseElement) # noqa: F401 from .argyris import Argyris # noqa: F401 from .aw import ArnoldWinther, ArnoldWintherNC # noqa: F401 diff --git a/finat/element_factory.py b/finat/element_factory.py index 5adcca5f9..a1947536e 100644 --- a/finat/element_factory.py +++ b/finat/element_factory.py @@ -306,8 +306,8 @@ def convert_restrictedelement(element, **kwargs): @convert.register(finat.ufl.FuseElement) -def convert_india_def(element, **kwargs): - return finat.fiat_elements.IndiaDefElement(element.triple), set() +def convert_fuse_element(element, **kwargs): + return finat.fiat_elements.FuseElement(element.triple), set() hexahedron_tpc = ufl.TensorProductCell(ufl.interval, ufl.interval, ufl.interval) diff --git a/finat/fiat_elements.py b/finat/fiat_elements.py index 4ac4aa7ba..e2b2d5107 100644 --- a/finat/fiat_elements.py +++ b/finat/fiat_elements.py @@ -482,6 +482,6 @@ def __init__(self, cell, degree, variant=None): super().__init__(FIAT.NedelecSecondKind(cell, degree, variant=variant)) -class IndiaDefElement(FiatElement): +class FuseElement(FiatElement): def __init__(self, triple): - super(IndiaDefElement, self).__init__(triple.to_fiat()) + super(FuseElement, self).__init__(triple.to_fiat()) From 2e3ed6c11a36e8f7ebcc9f35bff2d89691c336d6 Mon Sep 17 00:00:00 2001 From: India Marsden Date: Mon, 13 Jan 2025 15:00:07 +0000 Subject: [PATCH 14/20] Add test, small change to spatial dimension management --- FIAT/polynomial_set.py | 8 +++--- test/FIAT/unit/test_polynomial.py | 43 +++++++++++++++++++++++++++++++ 2 files changed, 47 insertions(+), 4 deletions(-) diff --git a/FIAT/polynomial_set.py b/FIAT/polynomial_set.py index 4f61968bd..f9b9e8f7e 100644 --- a/FIAT/polynomial_set.py +++ b/FIAT/polynomial_set.py @@ -202,18 +202,18 @@ def construct_new_coeffs(ref_el, A, B): if A.get_expansion_set().continuity != B.get_expansion_set().continuity: raise ValueError("Continuity of expansion sets does not match.") if A.get_embedded_degree() != B.get_embedded_degree() and A.get_expansion_set().continuity is None: - higher = A if A.degree > B.degree else B - lower = B if A.degree > B.degree else A + higher = A if A.get_embedded_degree() > B.get_embedded_degree() else B + lower = B if A.get_embedded_degree() > B.get_embedded_degree() else A try: sd = lower.get_shape()[0] except IndexError: - sd = 1 + sd = -1 embedded_coeffs = [] diff = higher.coeffs.shape[-1] - lower.coeffs.shape[-1] for coeff in lower.coeffs: - if sd > 1: + if sd != -1: new_coeff = [] for row in coeff: new_coeff.append(numpy.append(row, [0 for i in range(diff)])) diff --git a/test/FIAT/unit/test_polynomial.py b/test/FIAT/unit/test_polynomial.py index 2982cf11e..c211fb815 100644 --- a/test/FIAT/unit/test_polynomial.py +++ b/test/FIAT/unit/test_polynomial.py @@ -21,6 +21,7 @@ from FIAT import expansions, polynomial_set, reference_element from FIAT.quadrature_schemes import create_quadrature +from itertools import chain @pytest.fixture(params=(1, 2, 3)) @@ -107,3 +108,45 @@ def test_bubble_duality(cell, degree): results = scale * numpy.dot(numpy.multiply(phi_dual, qwts), phi.T) assert numpy.allclose(results, numpy.diag(numpy.diag(results))) assert numpy.allclose(numpy.diag(results), 1.0) + + +@pytest.mark.parametrize("degree", [10]) +def test_union_of_polysets(cell, degree): + """ demonstrates that polysets don't need to have the same degree for union + using RT space as an example""" + + sd = cell.get_spatial_dimension() + k = degree + vecPk = polynomial_set.ONPolynomialSet(cell, degree, (sd,)) + + vec_Pkp1 = polynomial_set.ONPolynomialSet(cell, k + 1, (sd,), scale="orthonormal") + + dimPkp1 = expansions.polynomial_dimension(cell, k + 1) + dimPk = expansions.polynomial_dimension(cell, k) + dimPkm1 = expansions.polynomial_dimension(cell, k - 1) + + vec_Pk_indices = list(chain(*(range(i * dimPkp1, i * dimPkp1 + dimPk) + for i in range(sd)))) + vec_Pk_from_Pkp1 = vec_Pkp1.take(vec_Pk_indices) + + Pkp1 = polynomial_set.ONPolynomialSet(cell, k + 1, scale="orthonormal") + PkH = Pkp1.take(list(range(dimPkm1, dimPk))) + + Q = create_quadrature(cell, 2 * (k + 1)) + Qpts, Qwts = Q.get_points(), Q.get_weights() + + PkH_at_Qpts = PkH.tabulate(Qpts)[(0,) * sd] + Pkp1_at_Qpts = Pkp1.tabulate(Qpts)[(0,) * sd] + x = Qpts.T + PkHx_at_Qpts = PkH_at_Qpts[:, None, :] * x[None, :, :] + PkHx_coeffs = numpy.dot(numpy.multiply(PkHx_at_Qpts, Qwts), Pkp1_at_Qpts.T) + PkHx = polynomial_set.PolynomialSet(cell, k, k + 1, vec_Pkp1.get_expansion_set(), PkHx_coeffs) + + same_deg = polynomial_set.polynomial_set_union_normalized(vec_Pk_from_Pkp1, PkHx) + different_deg = polynomial_set.polynomial_set_union_normalized(vecPk, PkHx) + + Q = create_quadrature(cell, 2*(degree)) + Qpts, _ = Q.get_points(), Q.get_weights() + same_vals = same_deg.tabulate(Qpts)[(0,) * sd] + diff_vals = different_deg.tabulate(Qpts)[(0,) * sd] + assert numpy.allclose(same_vals - diff_vals, 0) From 0b593e556b681ef4b02e252a39579683792c542d Mon Sep 17 00:00:00 2001 From: India Marsden Date: Wed, 15 Jan 2025 18:08:56 +0000 Subject: [PATCH 15/20] remove fuse dependency --- finat/element_factory.py | 7 ++++--- pyproject.toml | 1 - 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/finat/element_factory.py b/finat/element_factory.py index a1947536e..154336764 100644 --- a/finat/element_factory.py +++ b/finat/element_factory.py @@ -24,7 +24,6 @@ import finat import finat.ufl -from fuse.cells import CellComplexToUFL as FuseCell import ufl from FIAT import ufc_cell @@ -113,9 +112,11 @@ def as_fiat_cell(cell): :arg cell: the :class:`ufl.Cell` to convert.""" if not isinstance(cell, ufl.AbstractCell): raise ValueError("Expecting a UFL Cell") - if isinstance(cell, FuseCell): + + try: return cell.to_fiat() - return ufc_cell(cell) + except AttributeError: + return ufc_cell(cell) @singledispatch diff --git a/pyproject.toml b/pyproject.toml index 2d43b6dc5..c224c1fbe 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -12,7 +12,6 @@ dependencies = [ "symengine", "sympy", "fenics-ufl @ git+https://github.com/firedrakeproject/ufl.git", - "fuse-element @ git+https://github.com/indiamai/fuse.git", ] requires-python = ">=3.10" authors = [ From 263dad1326f2d56af4c37ebdfc6516a1a8705cc7 Mon Sep 17 00:00:00 2001 From: India Marsden Date: Thu, 16 Jan 2025 18:07:48 +0000 Subject: [PATCH 16/20] Modify code to use np.pad --- FIAT/polynomial_set.py | 26 +++++++++----------------- 1 file changed, 9 insertions(+), 17 deletions(-) diff --git a/FIAT/polynomial_set.py b/FIAT/polynomial_set.py index f9b9e8f7e..9686cf245 100644 --- a/FIAT/polynomial_set.py +++ b/FIAT/polynomial_set.py @@ -198,32 +198,24 @@ def construct_new_coeffs(ref_el, A, B): This does not handle the case that A and B have continuity but not the same degree. """ - sd = ref_el.get_spatial_dimension() if A.get_expansion_set().continuity != B.get_expansion_set().continuity: raise ValueError("Continuity of expansion sets does not match.") + if A.get_embedded_degree() != B.get_embedded_degree() and A.get_expansion_set().continuity is None: higher = A if A.get_embedded_degree() > B.get_embedded_degree() else B lower = B if A.get_embedded_degree() > B.get_embedded_degree() else A - try: - sd = lower.get_shape()[0] - except IndexError: - sd = -1 - - embedded_coeffs = [] diff = higher.coeffs.shape[-1] - lower.coeffs.shape[-1] - for coeff in lower.coeffs: - if sd != -1: - new_coeff = [] - for row in coeff: - new_coeff.append(numpy.append(row, [0 for i in range(diff)])) - embedded_coeffs.append(new_coeff) - else: - embedded_coeffs.append(numpy.append(coeff, [0 for i in range(diff)])) - embedded_coeffs = numpy.array(embedded_coeffs) + + # pad only the 0th axis with the difference in size + padding = [(0, 0) for i in range(len(lower.coeffs.shape) - 1)] + [(0, diff)] + embedded_coeffs = numpy.pad(lower.coeffs, padding) + new_coeffs = numpy.concatenate((embedded_coeffs, higher.coeffs), axis=0) - else: + elif A.get_embedded_degree() == B.get_embedded_degree(): new_coeffs = numpy.concatenate((A.coeffs, B.coeffs), axis=0) + else: + raise NotImplementedError("Extending of coefficients is not implemented for PolynomialSets with continuity and different degrees") return new_coeffs From ad63ee00ff4d2436394a0272455ac5ca53a0f042 Mon Sep 17 00:00:00 2001 From: India Marsden Date: Thu, 16 Jan 2025 18:41:20 +0000 Subject: [PATCH 17/20] Add extension of coefficients to allow union of polysets with different degrees --- FIAT/nedelec.py | 8 +++--- FIAT/polynomial_set.py | 40 +++++++++++++++++++++++++--- FIAT/raviart_thomas.py | 6 ++--- test/FIAT/unit/test_polynomial.py | 43 +++++++++++++++++++++++++++++++ 4 files changed, 87 insertions(+), 10 deletions(-) diff --git a/FIAT/nedelec.py b/FIAT/nedelec.py index c92fa06be..7be2efcb8 100644 --- a/FIAT/nedelec.py +++ b/FIAT/nedelec.py @@ -22,7 +22,7 @@ def NedelecSpace2D(ref_el, degree): raise Exception("NedelecSpace2D requires 2d reference element") k = degree - 1 - vec_Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1, (sd,)) + vec_Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1, (sd,), scale="orthonormal") dimPkp1 = expansions.polynomial_dimension(ref_el, k + 1) dimPk = expansions.polynomial_dimension(ref_el, k) @@ -32,7 +32,7 @@ def NedelecSpace2D(ref_el, degree): for i in range(sd)))) vec_Pk_from_Pkp1 = vec_Pkp1.take(vec_Pk_indices) - Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1) + Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1, scale="orthonormal") PkH = Pkp1.take(list(range(dimPkm1, dimPk))) Q = create_quadrature(ref_el, 2 * (k + 1)) @@ -43,8 +43,8 @@ def NedelecSpace2D(ref_el, degree): CrossX = numpy.dot(numpy.array([[0.0, 1.0], [-1.0, 0.0]]), Qpts.T) PkHCrossX_at_Qpts = PkH_at_Qpts[:, None, :] * CrossX[None, :, :] - PkHCrossX_coeffs = numpy.dot(numpy.multiply(PkHCrossX_at_Qpts, Qwts), Pkp1_at_Qpts.T) - + PkHCrossX_coeffs = numpy.dot(numpy.multiply(PkHCrossX_at_Qpts, Qwts), + Pkp1_at_Qpts.T) PkHcrossX = polynomial_set.PolynomialSet(ref_el, k + 1, k + 1, diff --git a/FIAT/polynomial_set.py b/FIAT/polynomial_set.py index 08e62b8d8..9686cf245 100644 --- a/FIAT/polynomial_set.py +++ b/FIAT/polynomial_set.py @@ -176,15 +176,49 @@ def polynomial_set_union_normalized(A, B): not contain any of the same members of the set, as we construct a span via SVD. """ - new_coeffs = numpy.concatenate((A.coeffs, B.coeffs), axis=0) + assert A.get_reference_element() == B.get_reference_element() + new_coeffs = construct_new_coeffs(A.get_reference_element(), A, B) + + deg = max(A.get_degree(), B.get_degree()) + em_deg = max(A.get_embedded_degree(), B.get_embedded_degree()) coeffs = spanning_basis(new_coeffs) return PolynomialSet(A.get_reference_element(), - A.get_degree(), - A.get_embedded_degree(), + deg, + em_deg, A.get_expansion_set(), coeffs) +def construct_new_coeffs(ref_el, A, B): + """ + Constructs new coefficients for the set union of A and B + If A and B are discontinuous and do not have the same degree the smaller one + is extended to match the larger. + + This does not handle the case that A and B have continuity but not the same degree. + """ + + if A.get_expansion_set().continuity != B.get_expansion_set().continuity: + raise ValueError("Continuity of expansion sets does not match.") + + if A.get_embedded_degree() != B.get_embedded_degree() and A.get_expansion_set().continuity is None: + higher = A if A.get_embedded_degree() > B.get_embedded_degree() else B + lower = B if A.get_embedded_degree() > B.get_embedded_degree() else A + + diff = higher.coeffs.shape[-1] - lower.coeffs.shape[-1] + + # pad only the 0th axis with the difference in size + padding = [(0, 0) for i in range(len(lower.coeffs.shape) - 1)] + [(0, diff)] + embedded_coeffs = numpy.pad(lower.coeffs, padding) + + new_coeffs = numpy.concatenate((embedded_coeffs, higher.coeffs), axis=0) + elif A.get_embedded_degree() == B.get_embedded_degree(): + new_coeffs = numpy.concatenate((A.coeffs, B.coeffs), axis=0) + else: + raise NotImplementedError("Extending of coefficients is not implemented for PolynomialSets with continuity and different degrees") + return new_coeffs + + class ONSymTensorPolynomialSet(PolynomialSet): """Constructs an orthonormal basis for symmetric-tensor-valued polynomials on a reference element. diff --git a/FIAT/raviart_thomas.py b/FIAT/raviart_thomas.py index db0058d12..2b9241899 100644 --- a/FIAT/raviart_thomas.py +++ b/FIAT/raviart_thomas.py @@ -20,7 +20,7 @@ def RTSpace(ref_el, degree): sd = ref_el.get_spatial_dimension() k = degree - 1 - vec_Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1, (sd,)) + vec_Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1, (sd,), scale="orthonormal") dimPkp1 = expansions.polynomial_dimension(ref_el, k + 1) dimPk = expansions.polynomial_dimension(ref_el, k) @@ -30,7 +30,7 @@ def RTSpace(ref_el, degree): for i in range(sd)))) vec_Pk_from_Pkp1 = vec_Pkp1.take(vec_Pk_indices) - Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1) + Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1, scale="orthonormal") PkH = Pkp1.take(list(range(dimPkm1, dimPk))) Q = create_quadrature(ref_el, 2 * (k + 1)) @@ -39,12 +39,12 @@ def RTSpace(ref_el, degree): # have to work on this through "tabulate" interface # first, tabulate PkH at quadrature points PkH_at_Qpts = PkH.tabulate(Qpts)[(0,) * sd] + Pkp1_at_Qpts = Pkp1.tabulate(Qpts)[(0,) * sd] x = Qpts.T PkHx_at_Qpts = PkH_at_Qpts[:, None, :] * x[None, :, :] PkHx_coeffs = numpy.dot(numpy.multiply(PkHx_at_Qpts, Qwts), Pkp1_at_Qpts.T) - PkHx = polynomial_set.PolynomialSet(ref_el, k, k + 1, diff --git a/test/FIAT/unit/test_polynomial.py b/test/FIAT/unit/test_polynomial.py index 2982cf11e..c211fb815 100644 --- a/test/FIAT/unit/test_polynomial.py +++ b/test/FIAT/unit/test_polynomial.py @@ -21,6 +21,7 @@ from FIAT import expansions, polynomial_set, reference_element from FIAT.quadrature_schemes import create_quadrature +from itertools import chain @pytest.fixture(params=(1, 2, 3)) @@ -107,3 +108,45 @@ def test_bubble_duality(cell, degree): results = scale * numpy.dot(numpy.multiply(phi_dual, qwts), phi.T) assert numpy.allclose(results, numpy.diag(numpy.diag(results))) assert numpy.allclose(numpy.diag(results), 1.0) + + +@pytest.mark.parametrize("degree", [10]) +def test_union_of_polysets(cell, degree): + """ demonstrates that polysets don't need to have the same degree for union + using RT space as an example""" + + sd = cell.get_spatial_dimension() + k = degree + vecPk = polynomial_set.ONPolynomialSet(cell, degree, (sd,)) + + vec_Pkp1 = polynomial_set.ONPolynomialSet(cell, k + 1, (sd,), scale="orthonormal") + + dimPkp1 = expansions.polynomial_dimension(cell, k + 1) + dimPk = expansions.polynomial_dimension(cell, k) + dimPkm1 = expansions.polynomial_dimension(cell, k - 1) + + vec_Pk_indices = list(chain(*(range(i * dimPkp1, i * dimPkp1 + dimPk) + for i in range(sd)))) + vec_Pk_from_Pkp1 = vec_Pkp1.take(vec_Pk_indices) + + Pkp1 = polynomial_set.ONPolynomialSet(cell, k + 1, scale="orthonormal") + PkH = Pkp1.take(list(range(dimPkm1, dimPk))) + + Q = create_quadrature(cell, 2 * (k + 1)) + Qpts, Qwts = Q.get_points(), Q.get_weights() + + PkH_at_Qpts = PkH.tabulate(Qpts)[(0,) * sd] + Pkp1_at_Qpts = Pkp1.tabulate(Qpts)[(0,) * sd] + x = Qpts.T + PkHx_at_Qpts = PkH_at_Qpts[:, None, :] * x[None, :, :] + PkHx_coeffs = numpy.dot(numpy.multiply(PkHx_at_Qpts, Qwts), Pkp1_at_Qpts.T) + PkHx = polynomial_set.PolynomialSet(cell, k, k + 1, vec_Pkp1.get_expansion_set(), PkHx_coeffs) + + same_deg = polynomial_set.polynomial_set_union_normalized(vec_Pk_from_Pkp1, PkHx) + different_deg = polynomial_set.polynomial_set_union_normalized(vecPk, PkHx) + + Q = create_quadrature(cell, 2*(degree)) + Qpts, _ = Q.get_points(), Q.get_weights() + same_vals = same_deg.tabulate(Qpts)[(0,) * sd] + diff_vals = different_deg.tabulate(Qpts)[(0,) * sd] + assert numpy.allclose(same_vals - diff_vals, 0) From 3a5b073187c4540b75f54fa1ad5155ef12b7d135 Mon Sep 17 00:00:00 2001 From: India Marsden Date: Fri, 17 Jan 2025 16:28:35 +0000 Subject: [PATCH 18/20] Small changes to allow different topologies --- FIAT/lagrange.py | 2 +- FIAT/reference_element.py | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/FIAT/lagrange.py b/FIAT/lagrange.py index eead0cfa6..dab845446 100644 --- a/FIAT/lagrange.py +++ b/FIAT/lagrange.py @@ -40,7 +40,7 @@ def __init__(self, ref_el, degree, point_variant="equispaced", sort_entities=Fal entities = [(dim, entity) for dim in sorted(top) for entity in sorted(top[dim])] if sort_entities: # sort the entities by support vertex ids - support = [top[dim][entity] for dim, entity in entities] + support = [sorted(top[dim][entity]) for dim, entity in entities] entities = [entity for verts, entity in sorted(zip(support, entities))] # make nodes by getting points diff --git a/FIAT/reference_element.py b/FIAT/reference_element.py index 7d9ff2968..cbb7607e3 100644 --- a/FIAT/reference_element.py +++ b/FIAT/reference_element.py @@ -515,7 +515,8 @@ def make_points(self, dim, entity_id, order, variant=None): facet of dimension dim. Order indicates how many points to include in each direction.""" if dim == 0: - return (self.get_vertices()[entity_id], ) + return (self.get_vertices()[self.get_topology()[dim][entity_id][0]],) + # return (self.get_vertices()[entity_id], ) elif 0 < dim <= self.get_spatial_dimension(): entity_verts = \ self.get_vertices_of_subcomplex( From 8d52e227a3f5852d00d98bd1ff9146447f24b295 Mon Sep 17 00:00:00 2001 From: India Marsden Date: Wed, 22 Jan 2025 14:19:58 +0000 Subject: [PATCH 19/20] remove orthonormal as seems to be no longer necessary --- FIAT/nedelec.py | 2 +- FIAT/raviart_thomas.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/FIAT/nedelec.py b/FIAT/nedelec.py index 7be2efcb8..db8b26b3b 100644 --- a/FIAT/nedelec.py +++ b/FIAT/nedelec.py @@ -22,7 +22,7 @@ def NedelecSpace2D(ref_el, degree): raise Exception("NedelecSpace2D requires 2d reference element") k = degree - 1 - vec_Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1, (sd,), scale="orthonormal") + vec_Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1, (sd,)) dimPkp1 = expansions.polynomial_dimension(ref_el, k + 1) dimPk = expansions.polynomial_dimension(ref_el, k) diff --git a/FIAT/raviart_thomas.py b/FIAT/raviart_thomas.py index 2b9241899..21b45d0b1 100644 --- a/FIAT/raviart_thomas.py +++ b/FIAT/raviart_thomas.py @@ -20,7 +20,7 @@ def RTSpace(ref_el, degree): sd = ref_el.get_spatial_dimension() k = degree - 1 - vec_Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1, (sd,), scale="orthonormal") + vec_Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1, (sd,)) dimPkp1 = expansions.polynomial_dimension(ref_el, k + 1) dimPk = expansions.polynomial_dimension(ref_el, k) From 8eaa60cf3ee656a4162cccbd2b99fb3697f5e045 Mon Sep 17 00:00:00 2001 From: India Marsden Date: Thu, 23 Jan 2025 10:54:50 +0000 Subject: [PATCH 20/20] Remove further orthonormals --- FIAT/nedelec.py | 2 +- FIAT/raviart_thomas.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/FIAT/nedelec.py b/FIAT/nedelec.py index db8b26b3b..6cf122772 100644 --- a/FIAT/nedelec.py +++ b/FIAT/nedelec.py @@ -32,7 +32,7 @@ def NedelecSpace2D(ref_el, degree): for i in range(sd)))) vec_Pk_from_Pkp1 = vec_Pkp1.take(vec_Pk_indices) - Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1, scale="orthonormal") + Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1) PkH = Pkp1.take(list(range(dimPkm1, dimPk))) Q = create_quadrature(ref_el, 2 * (k + 1)) diff --git a/FIAT/raviart_thomas.py b/FIAT/raviart_thomas.py index 21b45d0b1..2c7d72c83 100644 --- a/FIAT/raviart_thomas.py +++ b/FIAT/raviart_thomas.py @@ -30,7 +30,7 @@ def RTSpace(ref_el, degree): for i in range(sd)))) vec_Pk_from_Pkp1 = vec_Pkp1.take(vec_Pk_indices) - Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1, scale="orthonormal") + Pkp1 = polynomial_set.ONPolynomialSet(ref_el, k + 1) PkH = Pkp1.take(list(range(dimPkm1, dimPk))) Q = create_quadrature(ref_el, 2 * (k + 1))