ngstrefftz 0.3.2507.dev4__tar.gz → 0.3.2507.dev7__tar.gz

{ngstrefftz-0.3.2507.dev4 → ngstrefftz-0.3.2507.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ngstrefftz
-Version: 0.3.2507.dev4
+Version: 0.3.2507.dev7
 Summary: NGSTrefftz is an add-on to NGSolve for Trefftz methods.
 Author-Email: Paul Stocker <paul.stocker@univie.ac.at>
 Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)

{ngstrefftz-0.3.2507.dev4 → ngstrefftz-0.3.2507.dev7}/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.2507.dev4'
-__version_tuple__ = version_tuple = (0, 3, 2507, 'dev4')
+__version__ = version = '0.3.2507.dev7'
+__version_tuple__ = version_tuple = (0, 3, 2507, 'dev7')
 
-__commit_id__ = commit_id = 'g393c1d49d'
+__commit_id__ = commit_id = 'gc1672b4a2'

ngstrefftz-0.3.2507.dev7/src/tp0fespace.cpp

@@ -0,0 +1,270 @@
+#include <comp.hpp>
+#include <python_comp.hpp>
+#include "tp0fespace.hpp"
+
+namespace ngcomp
+{
+
+  void
+  TP0FE ::CalcShape (const IntegrationPoint &ip, BareSliceVector<> shape) const
+  {
+    double x = ip.Point ()[0], y = ip.Point ()[1];
+    double xi = (2 * x - 1);
+    double eta = (2 * y - 1);
+
+    if (zero_axis == 1)
+      swap (xi, eta);
+
+    size_t p = order;
+    size_t q = order - 2;
+
+    STACK_ARRAY (double, mem, p + q + 2);
+    double *polx = &mem[0];
+    double *poly = &mem[p + 1];
+
+    LegendrePolynomial (p, xi, polx);
+    LegendrePolynomial (q, eta, poly);
+
+    for (size_t i = 0, ii = 0; i <= p; i++)
+      for (size_t j = 0; j <= q; j++)
+        shape[ii++] = polx[i] * poly[j] * (1 - eta) * (1 + eta);
+  }
+
+  void TP0FE ::CalcDShape (const IntegrationPoint &ip,
+                           BareSliceMatrix<> dshape) const
+  {
+    AutoDiff<2> x (ip.Point ()[0], 0);
+    AutoDiff<2> y (ip.Point ()[1], 1);
+    AutoDiff<2> xi = (2 * x - 1);
+    AutoDiff<2> eta = (2 * y - 1);
+
+    if (zero_axis == 1)
+      swap (xi, eta);
+
+    size_t p = order;
+    size_t q = order - 2;
+
+    STACK_ARRAY (AutoDiff<2>, mem, p + q + 2);
+    AutoDiff<2> *polx = &mem[0];
+    AutoDiff<2> *poly = &mem[p + 1];
+
+    LegendrePolynomial (p, xi, polx);
+    LegendrePolynomial (q, eta, poly);
+
+    for (size_t i = 0, ii = 0; i <= p; i++)
+      for (size_t j = 0; j <= q; j++)
+        {
+          AutoDiff<2> shape = polx[i] * poly[j] * (1 - eta) * (1 + eta);
+          dshape (ii, 0) = shape.DValue (0);
+          dshape (ii++, 1) = shape.DValue (1);
+        }
+  }
+
+  TP0FESpace ::TP0FESpace (shared_ptr<MeshAccess> ama, const Flags &flags)
+      : FESpace (ama, flags)
+  {
+    type = "TP0FESpace";
+
+    order = int (flags.GetNumFlag ("order", 3));
+
+    if (ma->GetDimension () == 2)
+      {
+        evaluator[VOL] = make_shared<T_DifferentialOperator<MyDiffOpId>> ();
+        flux_evaluator[VOL]
+            = make_shared<T_DifferentialOperator<MyDiffOpGradient>> ();
+      }
+    else
+      {
+        throw Exception ("TP0FESpace implemented only in 2D");
+      }
+  }
+
+  DocInfo TP0FESpace ::GetDocu ()
+  {
+    auto docu = FESpace::GetDocu ();
+    return docu;
+  }
+
+  int TP0FESpace ::LocalNDof (ELEMENT_TYPE eltype, int order) const
+  {
+    switch (eltype)
+      {
+      case ET_TRIG:
+        return (order - 1) * order / 2;
+      case ET_QUAD:
+        return (order + 1) * (order - 1);
+      default:
+        throw Exception ("TP0FESpace::LocalNDof: element type not supported");
+      }
+  }
+
+  void TP0FESpace ::Update ()
+  {
+    FESpace::Update ();
+    if (order_policy == OLDSTYLE_ORDER)
+      order_policy = CONSTANT_ORDER;
+
+    nel = ma->GetNE ();
+    first_element_dof.SetSize (nel);
+    if (order_policy == CONSTANT_ORDER || order_inner.Size () == 0)
+      {
+        order_inner.SetSize0 ();
+        ndof = 0;
+        for (int i = 0; i < nel; i++)
+          {
+            first_element_dof[i] = ndof;
+            ndof += LocalNDof (ma->GetElement (ElementId (VOL, i)).GetType (),
+                               this->order);
+          }
+        // ndof = LocalNDof (this->order) * nel;
+        SetNDof (ndof);
+      }
+    else if (order_policy == VARIABLE_ORDER)
+      {
+        ndof = 0;
+        for (int i = 0; i < nel; i++)
+          {
+            first_element_dof[i] = ndof;
+            ndof += LocalNDof (ma->GetElement (ElementId (VOL, i)).GetType (),
+                               order_inner[i]);
+          }
+        SetNDof (ndof);
+      }
+    else
+      throw Exception ("TP0FESpace: invalid order policy");
+
+    UpdateCouplingDofArray ();
+  }
+
+  void TP0FESpace ::SetOrder (NodeId ni, int norder)
+  {
+    if (order_policy == CONSTANT_ORDER || order_policy == NODE_TYPE_ORDER)
+      throw Exception ("In TP0FESpace::SetOrder. Order policy is "
+                       "constant or node-type!");
+    else if (order_policy == OLDSTYLE_ORDER)
+      order_policy = VARIABLE_ORDER;
+
+    if (order < 0)
+      order = 0;
+
+    if (CoDimension (ni.GetType (), ma->GetDimension ()) == 0)
+      {
+        if (order_inner.Size () == 0)
+          {
+            order_inner.SetSize (ma->GetNE ());
+            order_inner = this->order;
+          }
+        order_inner[ni.GetNr ()] = norder;
+      }
+    else
+      throw Exception (
+          "TP0FESpace::SetOrder requires NodeType of codimension 0!");
+  }
+
+  int TP0FESpace ::GetOrder (NodeId ni) const
+  {
+    if (CoDimension (ni.GetType (), ma->GetDimension ()) == 0
+        && ni.GetNr () < order_inner.Size ())
+      return order_inner[ni.GetNr ()];
+    return 0;
+  }
+
+  void TP0FESpace ::GetDofNrs (ElementId ei, Array<DofId> &dnums) const
+  {
+    dnums.SetSize (0);
+    if (!DefinedOn (ei) || ei.VB () != VOL)
+      return;
+    int first_dof = first_element_dof[ei.Nr ()];
+    int local_ndof;
+    if (order_inner.Size () > 0)
+      local_ndof
+          = LocalNDof (ma->GetElement (ei).GetType (), order_inner[ei.Nr ()]);
+    else
+      local_ndof = LocalNDof (ma->GetElement (ei).GetType (), this->order);
+    for (int j = first_dof; j < first_dof + local_ndof; j++)
+      dnums.Append (j);
+  }
+
+  void TP0FESpace ::UpdateCouplingDofArray ()
+  {
+    ctofdof.SetSize (ndof);
+    for (auto i : Range (ma->GetNE ()))
+      {
+        bool definedon = DefinedOn (ElementId (VOL, i));
+        Array<DofId> dofs;
+        GetDofNrs (i, dofs);
+        for (auto r : dofs)
+          ctofdof[r] = definedon ? LOCAL_DOF : UNUSED_DOF;
+      }
+  }
+
+  FiniteElement &TP0FESpace ::GetFE (ElementId ei, Allocator &alloc) const
+  {
+
+    Ngs_Element ngel = ma->GetElement (ei);
+    ELEMENT_TYPE eltype = ngel.GetType ();
+    int D = ma->GetDimension ();
+    int order = order_inner.Size () > 0 ? order_inner[ei.Nr ()] : this->order;
+
+    if (ei.IsVolume ())
+      {
+        if (D == 2)
+          switch (eltype)
+            {
+            case ET_QUAD:
+              {
+                ElementTransformation &trafo = ma->GetTrafo (ei, alloc);
+                IntegrationPoint ip;
+                Mat<2, 2> jac;
+                trafo.CalcJacobian (ip, jac);
+                double xscale = L2Norm (jac.Col (0));
+                double yscale = L2Norm (jac.Col (1));
+                int zero_axis = yscale > xscale ? 1 : 0;
+
+                return *(new (alloc)
+                             TP0FE (LocalNDof (ET_QUAD, order), order,
+                                    IVec<4> (ngel.Vertices ()), zero_axis));
+                break;
+              }
+            case ET_TRIG:
+              {
+                Ngs_Element ngel
+                    = ma->GetElement<ET_trait<ET_TRIG>::DIM, VOL> (ei.Nr ());
+                L2HighOrderFE<ET_TRIG> *hofe
+                    = new (alloc) L2HighOrderFE<ET_TRIG> ();
+                hofe->SetVertexNumbers (ngel.vertices);
+                hofe->L2HighOrderFE<ET_TRIG>::SetOrder (order - 2);
+                hofe->L2HighOrderFE<ET_TRIG>::ComputeNDof ();
+                return *hofe;
+                break;
+              }
+            default:
+              throw Exception ("eltype not supported in TP0FE");
+            }
+        else
+          throw Exception ("dimension not supported in TP0FE");
+      }
+    try
+      {
+        return SwitchET<ET_POINT, ET_SEGM, ET_TRIG, ET_QUAD> (
+            eltype, [&alloc] (auto et) -> FiniteElement & {
+              return *new (alloc) DummyFE<et.ElementType ()>;
+            });
+      }
+    catch (Exception &e)
+      {
+        throw Exception ("illegal element type in Trefftz::GetSurfaceFE");
+      }
+  }
+
+  static RegisterFESpace<TP0FESpace> initifes ("TP0FESpace");
+}
+
+#ifdef NGS_PYTHON
+void ExportTP0FESpace (py::module m)
+{
+  using namespace ngcomp;
+
+  ExportFESpace<TP0FESpace> (m, "TP0FESpace");
+}
+#endif // NGS_PYTHON

{ngstrefftz-0.3.2507.dev4 → ngstrefftz-0.3.2507.dev7}/src/tp0fespace.hpp

@@ -37,12 +37,20 @@ namespace ngcomp
                                 MAT &mat, LocalHeap &lh)
     {
       HeapReset hr (lh);
-      Cast (fel).CalcShape (mip.IP (), mat.Row (0));
-    }
-
-    static const TP0FE &Cast (const FiniteElement &fel)
-    {
-      return static_cast<const TP0FE &> (fel);
+      // Cast (fel).CalcShape (mip.IP (), mat.Row (0));
+      switch (fel.ElementType ())
+        {
+        case ET_QUAD:
+          static_cast<const TP0FE &> (fel).CalcShape (mip.IP (), mat.Row (0));
+          break;
+        case ET_TRIG:
+          static_cast<const L2HighOrderFE<ET_TRIG> &> (fel).CalcShape (
+              mip.IP (), mat.Row (0));
+          break;
+        default:
+          throw Exception ("MyDiffOpId: " + ToString (fel.ElementType ())
+                           + " not supported");
+        }
     }
   };
 
@@ -75,8 +83,11 @@ namespace ngcomp
 
   class TP0FESpace : public FESpace
   {
-    int local_ndof;
     int nel;
+    Array<int> order_inner;
+    Array<int> first_element_dof;
+
+    int LocalNDof (ELEMENT_TYPE eltype, int order) const;
 
   public:
     TP0FESpace (shared_ptr<MeshAccess> ama, const Flags &flags);
@@ -88,6 +99,9 @@ namespace ngcomp
     void Update () override;
     virtual void UpdateCouplingDofArray () override;
 
+    virtual void SetOrder (NodeId ni, int norder) override;
+    virtual int GetOrder (NodeId ni) const override;
+
     void GetDofNrs (ElementId ei, Array<DofId> &dnums) const override;
     FiniteElement &GetFE (ElementId ei, Allocator &alloc) const override;
   };

ngstrefftz-0.3.2507.dev4/src/tp0fespace.cpp

@@ -1,177 +0,0 @@
-#include <comp.hpp>
-#include <python_comp.hpp>
-#include "tp0fespace.hpp"
-
-namespace ngcomp
-{
-
-  void
-  TP0FE ::CalcShape (const IntegrationPoint &ip, BareSliceVector<> shape) const
-  {
-    double x = ip.Point ()[0], y = ip.Point ()[1];
-    double xi = (2 * x - 1);
-    double eta = (2 * y - 1);
-
-    if (zero_axis == 1)
-      swap (xi, eta);
-
-    size_t p = order;
-    size_t q = order - 2;
-
-    STACK_ARRAY (double, mem, p + q + 2);
-    double *polx = &mem[0];
-    double *poly = &mem[p + 1];
-
-    LegendrePolynomial (p, xi, polx);
-    LegendrePolynomial (q, eta, poly);
-
-    for (size_t i = 0, ii = 0; i <= p; i++)
-      for (size_t j = 0; j <= q; j++)
-        shape[ii++] = polx[i] * poly[j] * (1 - eta) * (1 + eta);
-  }
-
-  void TP0FE ::CalcDShape (const IntegrationPoint &ip,
-                           BareSliceMatrix<> dshape) const
-  {
-    AutoDiff<2> x (ip.Point ()[0], 0);
-    AutoDiff<2> y (ip.Point ()[1], 1);
-    AutoDiff<2> sigma[4]
-        = { (1 - x) + (1 - y), x + (1 - y), x + y, (1 - x) + y };
-
-    IVec<4> f = GetFaceSort (0, vnums);
-
-    AutoDiff<2> xi = sigma[f[0]] - sigma[f[1]];
-    AutoDiff<2> eta = sigma[f[0]] - sigma[f[3]];
-    if (zero_axis == 1)
-      swap (xi, eta);
-
-    size_t p = order;
-    size_t q = order - 2;
-
-    STACK_ARRAY (AutoDiff<2>, mem, p + q + 2);
-    AutoDiff<2> *polx = &mem[0];
-    AutoDiff<2> *poly = &mem[p + 1];
-
-    LegendrePolynomial (p, xi, polx);
-    LegendrePolynomial (q, eta, poly);
-
-    for (size_t i = 0, ii = 0; i <= p; i++)
-      for (size_t j = 0; j <= q; j++)
-        {
-          AutoDiff<2> shape = polx[i] * poly[j] * (1 + eta) * (1 - eta);
-          dshape (ii, 0) = shape.DValue (0);
-          dshape (ii++, 1) = shape.DValue (1);
-        }
-  }
-
-  TP0FESpace ::TP0FESpace (shared_ptr<MeshAccess> ama, const Flags &flags)
-      : FESpace (ama, flags)
-  {
-    type = "TP0FESpace";
-
-    order = int (flags.GetNumFlag ("order", 3));
-    local_ndof = (order + 1) * (order - 1);
-
-    if (ma->GetDimension () == 2)
-      {
-        evaluator[VOL] = make_shared<T_DifferentialOperator<MyDiffOpId>> ();
-        flux_evaluator[VOL]
-            = make_shared<T_DifferentialOperator<MyDiffOpGradient>> ();
-      }
-    else
-      {
-        throw Exception ("TP0FESpace implemented only in 2D");
-      }
-  }
-
-  DocInfo TP0FESpace ::GetDocu ()
-  {
-    auto docu = FESpace::GetDocu ();
-    return docu;
-  }
-
-  void TP0FESpace ::Update ()
-  {
-    FESpace::Update ();
-    nel = ma->GetNE ();
-    ndof = local_ndof * nel;
-    SetNDof (ndof);
-    UpdateCouplingDofArray ();
-  }
-
-  void TP0FESpace ::GetDofNrs (ElementId ei, Array<DofId> &dnums) const
-  {
-    dnums.SetSize (0);
-    if (!DefinedOn (ei) || ei.VB () != VOL)
-      return;
-    for (size_t j = ei.Nr () * local_ndof; j < local_ndof * (ei.Nr () + 1);
-         j++)
-      dnums.Append (j);
-  }
-
-  void TP0FESpace ::UpdateCouplingDofArray ()
-  {
-    ctofdof.SetSize (ndof);
-    for (auto i : Range (ma->GetNE ()))
-      {
-        bool definedon = DefinedOn (ElementId (VOL, i));
-        Array<DofId> dofs;
-        GetDofNrs (i, dofs);
-        for (auto r : dofs)
-          ctofdof[r] = definedon ? LOCAL_DOF : UNUSED_DOF;
-      }
-  }
-
-  FiniteElement &TP0FESpace ::GetFE (ElementId ei, Allocator &alloc) const
-  {
-
-    Ngs_Element ngel = ma->GetElement (ei);
-    ELEMENT_TYPE eltype = ngel.GetType ();
-    int D = ma->GetDimension ();
-
-    if (ei.IsVolume ())
-      {
-        switch (D)
-          {
-          case 2:
-            {
-              ElementTransformation &trafo = ma->GetTrafo (ei, alloc);
-              IntegrationPoint ip;
-              Mat<2, 2> jac;
-              trafo.CalcJacobian (ip, jac);
-              double xscale = L2Norm (jac.Col (0));
-              double yscale = L2Norm (jac.Col (1));
-
-              int zero_axis = yscale > xscale ? 1 : 0;
-              return *(new (alloc) TP0FE (
-                  local_ndof, order, IVec<4> (ngel.Vertices ()), zero_axis));
-              break;
-            }
-          default:
-            throw Exception ("dimension not supported in TP0FE");
-          }
-      }
-    try
-      {
-        return SwitchET<ET_POINT, ET_SEGM, ET_TRIG, ET_QUAD> (
-            eltype, [&alloc] (auto et) -> FiniteElement & {
-              return *new (alloc) DummyFE<et.ElementType ()>;
-            });
-      }
-    catch (Exception &e)
-      {
-        throw Exception ("illegal element type in Trefftz::GetSurfaceFE");
-      }
-  }
-
-  static RegisterFESpace<TP0FESpace> initifes ("TP0FESpace");
-}
-
-#ifdef NGS_PYTHON
-void ExportTP0FESpace (py::module m)
-{
-  using namespace ngcomp;
-
-  ExportFESpace<TP0FESpace> (m, "TP0FESpace");
-}
-#endif // NGS_PYTHON