ngstrefftz 0.3.2506.dev2__tar.gz → 0.3.2507.dev2__tar.gz

{ngstrefftz-0.3.2506.dev2 → ngstrefftz-0.3.2507.dev2}/CMakeLists.txt

@@ -55,6 +55,7 @@ add_ngsolve_addon(ngstrefftz
     src/pufe.cpp
     src/pufespace.cpp
     src/boxintegral.cpp
+    src/tp0fespace.cpp
     #src/airy.cpp #for testing, requires boost
   )
 target_compile_definitions(ngstrefftz PRIVATE NGSTREFFTZ_EXPORTS)

{ngstrefftz-0.3.2506.dev2 → ngstrefftz-0.3.2507.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ngstrefftz
-Version: 0.3.2506.dev2
+Version: 0.3.2507.dev2
 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.2506.dev2 → ngstrefftz-0.3.2507.dev2}/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.2506.dev2'
-__version_tuple__ = version_tuple = (0, 3, 2506, 'dev2')
+__version__ = version = '0.3.2507.dev2'
+__version_tuple__ = version_tuple = (0, 3, 2507, 'dev2')
 
-__commit_id__ = commit_id = 'g6778f15df'
+__commit_id__ = commit_id = 'gb2e7fc60b'

{ngstrefftz-0.3.2506.dev2 → ngstrefftz-0.3.2507.dev2}/src/embtrefftz.cpp

@@ -789,6 +789,8 @@ namespace ngcomp
             }
 
           shared_ptr<FlatMatrix<double>> fes_ip_sqinv = nullptr;
+          if (stats)
+            elmat_A_copy = elmat_A;
           if (fes_ip)
             {
               fes_ip_sqinv = make_shared<FlatMatrix<double>> (ndof, ndof, lh);
@@ -840,8 +842,6 @@ namespace ngcomp
 
           FlatMatrix<SCAL, ColMajor> UT (elmat_A.Height (), lh),
               V (elmat_A.Width (), lh);
-          if (stats)
-            elmat_A_copy = elmat_A;
           getSVD<SCAL> (elmat_A, UT, V);
 
           // # TODO: incorporate the double variant
@@ -884,7 +884,7 @@ namespace ngcomp
                   particular_solution_vec->SetIndirect (dofs, partsol);
                 }
               etmats_trefftz_inv[element_id.Nr ()]
-                  = make_optional<Matrix<SCAL>> (elmat_A_inv);
+                  = make_optional<Matrix<SCAL>> (elmat_T_inv);
             }
 
           if (ignoredofs)
@@ -1100,7 +1100,8 @@ namespace ngcomp
 
           if (fes->IsComplex ())
             {
-              auto elmat_T_inv = (*etmatsc_trefftz_inv[element_id.Nr ()]);
+              Matrix<Complex> elmat_T_inv
+                  = (*etmatsc_trefftz_inv[element_id.Nr ()]);
               FlatVector<Complex> partsol (dofs.Size (), lh);
               FlatVector<Complex> elvec (dofs_test.Size (), lh);
               _trhsvec->GetIndirect (dofs_test, elvec);
@@ -1109,7 +1110,7 @@ namespace ngcomp
             }
           else
             {
-              auto elmat_T_inv = *etmats_trefftz_inv[element_id.Nr ()];
+              Matrix<> elmat_T_inv = *etmats_trefftz_inv[element_id.Nr ()];
               FlatVector<double> partsol (dofs.Size (), lh);
               FlatVector<double> elvec (dofs_test.Size (), lh);
               _trhsvec->GetIndirect (dofs_test, elvec);

{ngstrefftz-0.3.2506.dev2 → ngstrefftz-0.3.2507.dev2}/src/embtrefftz.hpp

@@ -146,7 +146,6 @@ namespace ngcomp
           fes_conformity (emb->GetFESconf ()),
           ignoredofs (emb->GetIgnoredDofs ())
     {
-      assert (fes && "fes may not be nullptr");
       this->name
           = "EmbTrefftzFESpace(" + emb->GetFES ()->GetClassName () + ")";
       this->type = "embt";

{ngstrefftz-0.3.2506.dev2 → ngstrefftz-0.3.2507.dev2}/src/python_trefftz.cpp

@@ -15,6 +15,7 @@
 #include "pufespace.hpp"
 #include "condensedg.hpp"
 #include "boxintegral.hpp"
+#include "tp0fespace.hpp"
 // #include "airy.cpp"
 
 PYBIND11_MODULE (ngstrefftz, m)
@@ -34,6 +35,7 @@ PYBIND11_MODULE (ngstrefftz, m)
   ExportPUFESpace (m);
   ExportCondenseDG (m);
   ExportBoxIntegral (m);
+  ExportTP0FESpace (m);
   // ExportStdMathFunction<GenericAiry>(m, "airy", "airy function");
   // ExportStdMathFunction<GenericAiryP>(m, "airyp", "airyp function");
 }

{ngstrefftz-0.3.2506.dev2 → ngstrefftz-0.3.2507.dev2}/src/specialcoefficientfunction.cpp

@@ -313,6 +313,10 @@ void ExportSpecialCoefficientFunction (py::module m)
             }),
             py::arg ("mesh"), py::arg ("CoefficientFunction"));
 
+  py::class_<AdjacentFaceSizeCF, shared_ptr<AdjacentFaceSizeCF>,
+             CoefficientFunction> (m, "AdjacentFaceSizeCF")
+      .def (py::init ([] () { return new AdjacentFaceSizeCF (); }));
+
   // py::class_<TrefftzCoefficientFunction,
   // shared_ptr<TrefftzCoefficientFunction>, CoefficientFunction> (m,
   //"TrefftzCoefficient", "") .def(py::init<>()) .def(py::init<int>())

{ngstrefftz-0.3.2506.dev2 → ngstrefftz-0.3.2507.dev2}/src/specialcoefficientfunction.hpp

@@ -86,6 +86,38 @@ namespace ngfem
     ~PrintCF () { ofs->close (); }
   };
 
+  class AdjacentFaceSizeCF : public CoefficientFunction
+  {
+  public:
+    AdjacentFaceSizeCF () : CoefficientFunction (1, false) { ; }
+    virtual double
+    Evaluate (const BaseMappedIntegrationPoint &ip) const override
+    {
+      LocalHeap lh (100000, "AdjacentFaceSizeCF::Evaluate");
+      if (ip.IP ().FacetNr () != -1) // on a boundary facet of the element
+        {
+          switch (ip.DimSpace ())
+            {
+            case 2:
+              {
+                const MappedIntegrationPoint<2, 2> &mp
+                    = static_cast<const MappedIntegrationPoint<2, 2> &> (ip);
+                IntegrationPoint rip = mp.IP ();
+                if (rip.Point ()[0] == 0 || rip.Point ()[0] == 1)
+                  return L2Norm (mp.GetJacobian ().Col (0));
+                else
+                  return L2Norm (mp.GetJacobian ().Col (1));
+              }
+            default:
+              throw Exception ("Illegal dimension in MeshSizeCF");
+            }
+        }
+      else
+        throw Exception (
+            "AdjacentFaceSizeCF::Evaluate - not on a boundary facet");
+    }
+  };
+
 }
 
 #ifdef NGS_PYTHON

ngstrefftz-0.3.2507.dev2/src/tp0fespace.cpp

@@ -0,0 +1,177 @@
+#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

ngstrefftz-0.3.2507.dev2/src/tp0fespace.hpp

@@ -0,0 +1,102 @@
+#ifndef FILE_TP0FESPACE_HPP
+#define FILE_TP0FESPACE_HPP
+
+#include <fem.hpp>
+
+namespace ngcomp
+{
+  class TP0FE : public FiniteElement, public ET_trait<ET_QUAD>
+  {
+    FlatArray<int> vnums;
+    int zero_axis;
+
+  public:
+    TP0FE (int ndof, int order, FlatArray<int> avnums, int azero_axis)
+        : FiniteElement (ndof, order), vnums (avnums), zero_axis (azero_axis)
+    {
+      ;
+    }
+    ELEMENT_TYPE ElementType () const override { return ET_QUAD; }
+
+    void CalcShape (const IntegrationPoint &ip, BareSliceVector<> shape) const;
+    void
+    CalcDShape (const IntegrationPoint &ip, BareSliceMatrix<> dshape) const;
+  };
+
+  class MyDiffOpId : public DiffOp<MyDiffOpId>
+  {
+  public:
+    static constexpr int DIM = 1;
+    static constexpr int DIM_SPACE = 2;
+    static constexpr int DIM_ELEMENT = 2;
+    static constexpr int DIM_DMAT = 1;
+    static constexpr int DIFFORDER = 0;
+
+    template <typename MIP, typename MAT>
+    static void GenerateMatrix (const FiniteElement &fel, const MIP &mip,
+                                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);
+    }
+  };
+
+  class MyDiffOpGradient : public DiffOp<MyDiffOpGradient>
+  {
+  public:
+    static constexpr int DIM = 1;
+    static constexpr int DIM_SPACE = 2;
+    static constexpr int DIM_ELEMENT = 2;
+    static constexpr int DIM_DMAT = 2;
+    static constexpr int DIFFORDER = 1;
+
+    static string Name () { return "grad"; }
+
+    template <typename MIP, typename MAT>
+    static void GenerateMatrix (const FiniteElement &fel, const MIP &mip,
+                                MAT &mat, LocalHeap &lh)
+    {
+      HeapReset hr (lh);
+      FlatMatrixFixWidth<2> dshape (fel.GetNDof (), lh);
+      Cast (fel).CalcDShape (mip.IP (), dshape);
+      mat = Trans (dshape * mip.GetJacobianInverse ());
+    }
+
+    static const TP0FE &Cast (const FiniteElement &fel)
+    {
+      return static_cast<const TP0FE &> (fel);
+    }
+  };
+
+  class TP0FESpace : public FESpace
+  {
+    int local_ndof;
+    int nel;
+
+  public:
+    TP0FESpace (shared_ptr<MeshAccess> ama, const Flags &flags);
+
+    string GetClassName () const override { return "TP0FESpace"; }
+
+    static DocInfo GetDocu ();
+
+    void Update () override;
+    virtual void UpdateCouplingDofArray () override;
+
+    void GetDofNrs (ElementId ei, Array<DofId> &dnums) const override;
+    FiniteElement &GetFE (ElementId ei, Allocator &alloc) const override;
+  };
+
+}
+
+#ifdef NGS_PYTHON
+#include <python_ngstd.hpp>
+void ExportTP0FESpace (py::module m);
+#endif // NGS_PYTHON
+
+#endif