ngstrefftz 0.3.2406.dev89__tar.gz → 0.3.2502.dev2__tar.gz

{ngstrefftz-0.3.2406.dev89 → ngstrefftz-0.3.2502.dev2}/.github/workflows/build.yml

@@ -100,7 +100,7 @@ jobs:
           - os: ubuntu-latest
             doit: ${{ inputs.level == 'quick' }}
             cibw_build: cp313-*
-          - os: windows-2019
+          - os: windows-2022
             cibw-arch: AMD64
             cmake-generator: "Visual Studio 16 2019"
             cmake_generator_platform: "x64"

{ngstrefftz-0.3.2406.dev89 → ngstrefftz-0.3.2502.dev2}/Dockerfile

@@ -8,8 +8,8 @@ WORKDIR /home/app
 #RUN cd /home/app/ngstrefftz/docs && sphinx-build -M html . _build -vvv
 
 RUN pip install ngstrefftz --pre
-ENV PYTHONPATH=$PYTHONPATH:/usr/local/lib/python3.10/site-packages/
-ENV LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib/
+ENV PYTHONPATH=/usr/local/lib/python3.10/site-packages/
+ENV LD_LIBRARY_PATH=/usr/local/lib/
 
 RUN pip3 install numpy webgui_jupyter_widgets notebook
 #RUN pip3 install jupyter_contrib_nbextensions 
@@ -18,10 +18,9 @@ RUN pip3 install numpy webgui_jupyter_widgets notebook
 
 ARG NB_USER=jovyan
 ARG NB_UID=1000
-ENV USER ${NB_USER}
-ENV NB_UID ${NB_UID}
-ENV HOME /home/${NB_USER}
-#ENV mv /home/app/ngstrefftz/* /home/${NB_USER}/
+ENV USER=${NB_USER}
+ENV NB_UID=${NB_UID}
+ENV HOME=/home/${NB_USER}
 
 RUN adduser --disabled-password \
     --gecos "Default user" \

{ngstrefftz-0.3.2406.dev89 → ngstrefftz-0.3.2502.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ngstrefftz
-Version: 0.3.2406.dev89
+Version: 0.3.2502.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.2406.dev89 → ngstrefftz-0.3.2502.dev2}/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3.2406.dev89'
-__version_tuple__ = version_tuple = (0, 3, 2406, 'dev89')
+__version__ = version = '0.3.2502.dev2'
+__version_tuple__ = version_tuple = (0, 3, 2502, 'dev2')

{ngstrefftz-0.3.2406.dev89 → ngstrefftz-0.3.2502.dev2}/docs/requirements.txt

@@ -21,6 +21,6 @@ myst_parser>=3.0.1
 numpy>=2.0.0
 scipy>=1.13.1
 webgui-jupyter-widgets>=0.2.35
-#ngstrefftz>=0.3.2404.post156 --pre
+#ngstrefftz==0.3.2501
 #ngsolve==6.2.2404.post22.dev0
-#xfem>=2.1.2404
+xfem==2.1.2501

{ngstrefftz-0.3.2406.dev89 → ngstrefftz-0.3.2502.dev2}/src/embtrefftz.cpp

@@ -522,56 +522,77 @@ namespace ngbla
   }
 #endif
 
-  /// `A = U * Sigma * V`
-  /// A gets overwritten with Sigma
+  /// `A^T = V * Sigma^T * U^T`
+  /// A gets overwritten with Sigma^T
   /// @param A has dimension n * m
   /// @param U has dimension n * n
   /// @param V has dimension m * m
   template <typename SCAL, typename TDIST>
-  void getSVD (MatrixView<SCAL, ngbla::RowMajor, size_t, size_t, TDIST> A,
-               FlatMatrix<SCAL, ColMajor> U, FlatMatrix<SCAL, ColMajor> V)
+  void
+  getSVD (MatrixView<SCAL, ngbla::RowMajor, size_t, size_t, TDIST> A_to_sigmaT,
+          FlatMatrix<SCAL, ColMajor> UT, FlatMatrix<SCAL, ColMajor> V)
   {
-    auto [height, width] = A.Shape ();
-    Matrix<SCAL, ColMajor> AA (height, width);
-    AA = A;
-
-    // Matrix<SCAL,ColMajor> AA(A.Height(),A.Width());
-    // for(int i=0;i<A.Height();i++)
-    // for(int j=0;j<A.Width();j++)
-    // AA(i,j)= A(i,j);
+    auto [Aheight, Awidth] = A_to_sigmaT.Shape ();
+    FlatMatrix<SCAL, ColMajor> AT (Awidth, Aheight, &A_to_sigmaT (0, 0));
+    // FlatMatrix<SCAL, ColMajor> VT (Aheight, Aheight, &UT(0,0));
+    // FlatMatrix<SCAL, ColMajor> U (Awidth, Awidth, &V(0,0));
+    // Matrix<SCAL, ColMajor> AA (height, width);
+    // AA = A;
+
 #ifdef NGSTREFFTZ_USE_LAPACK
-    LapackSVD (AA, U, V);
+    LapackSVD (AT, V, UT);
 #else
     cout << "No Lapack, using CalcSVD" << endl;
-    CalcSVD (AA, U, V);
+    CalcSVD (AT, V, UT);
 #endif
-    A = static_cast<SCAL> (0.0);
-    // A.Diag(0)=AA.Diag();
-    for (size_t i = 0; i < min (A.Width (), A.Height ()); i++)
-      A (i, i) = AA (i, i);
+
+    // A = static_cast<SCAL> (0.0);
+    //  A.Diag(0)=AA.Diag();
+    // for (size_t i = 0; i < min (A.Width (), A.Height ()); i++)
+    // A (i, i) = AA (i, i);
   }
 }
 
 /// @param num_zero number of singular values `sigma_i = 0` in the matrix Sigma
 /// @return pseudoinverse of A (as some `ngbla::Expr` type to avoid
 /// allocations)
-template <typename SCAL, typename TDIST>
+template <typename SCAL, typename TDIST, ORDERING SIG_ORD>
 Matrix<SCAL>
-invertSVD (const FlatMatrix<SCAL, ColMajor> &U,
-           const MatrixView<SCAL, RowMajor, size_t, size_t, TDIST> &Sigma,
+invertSVD (const FlatMatrix<SCAL, ColMajor> &UT,
+           const MatrixView<SCAL, SIG_ORD, size_t, size_t, TDIST> &Sigma,
            const FlatMatrix<SCAL, ColMajor> &V, size_t num_zero, LocalHeap &lh)
 {
   const HeapReset hr (lh);
   const auto [m, n] = Sigma.Shape ();
 
-  FlatMatrix<SCAL> sigma_inv_times_ut (n, U.Height (), lh);
+  FlatMatrix<SCAL> sigma_inv_times_ut (n, UT.Width (), lh);
   for (size_t i = 0; i < n; i++)
     if (i < min (n - num_zero, m))
-      sigma_inv_times_ut.Row (i) = 1.0 / Sigma (i, i) * U.Col (i);
+      sigma_inv_times_ut.Row (i) = 1.0 / Sigma (i, i) * UT.Row (i);
     else
       sigma_inv_times_ut.Row (i) = SCAL (0.);
 
-  return Trans (V) * sigma_inv_times_ut;
+  return V * sigma_inv_times_ut;
+}
+
+/// @returns the pseudo-inverse of `mat`
+/// @param num_zero number of (near) zero singular values in `mat`
+template <typename SCAL>
+Matrix<SCAL>
+getPseudoInverse (const FlatMatrix<SCAL> mat, const size_t num_zero)
+{
+  LocalHeap lh = LocalHeap (100 * 1000 * 1000, "embt");
+  const auto [n, m] = mat.Shape ();
+  FlatMatrix<SCAL> sigma (n, m, lh);
+  FlatMatrix<SCAL, ColMajor> UT (n, n, lh);
+  FlatMatrix<SCAL, ColMajor> V (m, m, lh);
+
+  Matrix<SCAL> elmat_inv (m, n);
+
+  sigma = mat;
+  getSVD (sigma, UT, V);
+  elmat_inv = invertSVD (UT, sigma, V, num_zero, lh);
+  return elmat_inv;
 }
 
 /// calculates from the given space and linear form integrators a particular
@@ -662,7 +683,7 @@ namespace ngcomp
       }
 
     Array<optional<Matrix<SCAL>>> etmats (num_elements);
-    Array<optional<Matrix<SCAL>>> etmats_inv (num_elements);
+    Array<optional<Matrix<SCAL>>> etmats_trefftz_inv (num_elements);
     Array<size_t> local_ndofs_trefftz (num_elements);
 
     const bool any_fes_has_inactive_dofs
@@ -765,9 +786,9 @@ namespace ngcomp
           // #TODO: why is this necessary?
           reorderMatrixColumns (elmat_Cr, dofs_conforming, lh);
 
-          FlatMatrix<SCAL, ColMajor> U (elmat_A.Height (), lh),
+          FlatMatrix<SCAL, ColMajor> UT (elmat_A.Height (), lh),
               V (elmat_A.Width (), lh);
-          getSVD<SCAL> (elmat_A, U, V);
+          getSVD<SCAL> (elmat_A, UT, V);
 
           // # TODO: incorporate the double variant
           const size_t ndof_trefftz_i
@@ -777,7 +798,7 @@ namespace ngcomp
             throw std::invalid_argument ("zero trefftz dofs");
 
           const auto elmat_A_inv_expr
-              = invertSVD (U, elmat_A, V, ndof_trefftz_i, lh);
+              = invertSVD (UT, elmat_A, V, ndof_trefftz_i, lh);
           FlatMatrix<SCAL> elmat_A_inv (ndof, ndof_conforming + ndof_test, lh);
           // Calculate the matrix entries and write them to memory.
           elmat_A_inv = elmat_A_inv_expr;
@@ -791,16 +812,22 @@ namespace ngcomp
 
           // if (get_range)
           // elmat_Tt = U.Cols (0, dofs.Size () - ndof_trefftz_i);
-          elmat_Tt = Trans (V.Rows (ndof - ndof_trefftz_i, ndof));
+          elmat_Tt = V.Cols (ndof - ndof_trefftz_i, ndof);
 
-          if (trhs)
+          if (compute_elmat_T_inv)
             {
               auto elmat_T_inv = elmat_A_inv.Cols (
                   ndof_conforming, ndof_conforming + ndof_test);
-              FlatVector<SCAL> partsol (dofs.Size (), lh);
-              calculateParticularSolution<SCAL> (
-                  partsol, lfis, *fes_test, element_id, *ma, elmat_T_inv, lh);
-              particular_solution_vec->SetIndirect (dofs, partsol);
+              if (trhs)
+                {
+                  FlatVector<SCAL> partsol (dofs.Size (), lh);
+                  calculateParticularSolution<SCAL> (partsol, lfis, *fes_test,
+                                                     element_id, *ma,
+                                                     elmat_T_inv, lh);
+                  particular_solution_vec->SetIndirect (dofs, partsol);
+                }
+              etmats_trefftz_inv[element_id.Nr ()]
+                  = make_optional<Matrix<SCAL>> (elmat_A_inv);
             }
 
           if (ignoredofs)
@@ -808,8 +835,6 @@ namespace ngcomp
                                           ignoredofs);
 
           etmats[element_id.Nr ()] = make_optional<Matrix<SCAL>> (elmat_T);
-          etmats_inv[element_id.Nr ()]
-              = make_optional<Matrix<SCAL>> (elmat_A_inv);
           local_ndofs_trefftz[element_id.Nr ()] = ndof_trefftz_i;
 
           if (stats)
@@ -854,13 +879,13 @@ namespace ngcomp
 
     if constexpr (std::is_same_v<double, SCAL>)
       {
-        this->etmats = etmats;
-        this->etmats_inv = etmats_inv;
+        this->etmats = std::move (etmats);
+        this->etmats_trefftz_inv = std::move (etmats_trefftz_inv);
       }
     else
       {
-        this->etmatsc = etmats;
-        this->etmatsc_inv = etmats_inv;
+        this->etmatsc = std::move (etmats);
+        this->etmatsc_trefftz_inv = std::move (etmats_trefftz_inv);
       }
     this->local_ndofs_trefftz = local_ndofs_trefftz;
     this->psol = particular_solution_vec;
@@ -871,9 +896,10 @@ namespace ngcomp
       shared_ptr<SumOfIntegrals> _cop, shared_ptr<SumOfIntegrals> _crhs,
       size_t _ndof_trefftz, double _eps, shared_ptr<FESpace> _fes,
       shared_ptr<FESpace> _fes_test, shared_ptr<FESpace> _fes_conformity,
-      shared_ptr<BitArray> _ignoredofs)
+      shared_ptr<BitArray> _ignoredofs,
+      shared_ptr<std::map<std::string, Vector<double>>> _stats)
       : top (_top), trhs (_trhs), cop (_cop), crhs (_crhs),
-        ignoredofs (_ignoredofs)
+        ignoredofs (_ignoredofs), stats (_stats)
   {
     if (_ndof_trefftz == 0)
       ndof_trefftz = _eps;
@@ -944,9 +970,7 @@ namespace ngcomp
 
           if (fes->IsComplex ())
             {
-              const size_t width = (*etmatsc_inv[element_id.Nr ()]).Width ();
-              auto elmat_T_inv = (*etmatsc_inv[element_id.Nr ()])
-                                     .Cols (width - dofs_test.Size (), width);
+              auto elmat_T_inv = (*etmatsc_trefftz_inv[element_id.Nr ()]);
               FlatVector<Complex> partsol (dofs.Size (), lh);
               calculateParticularSolution<Complex> (
                   partsol, lfis, *fes_test, element_id, *ma, elmat_T_inv, lh);
@@ -954,9 +978,7 @@ namespace ngcomp
             }
           else
             {
-              const size_t width = (*etmats_inv[element_id.Nr ()]).Width ();
-              auto elmat_T_inv = (*etmats_inv[element_id.Nr ()])
-                                     .Cols (width - dofs_test.Size (), width);
+              auto elmat_T_inv = *etmats_trefftz_inv[element_id.Nr ()];
               FlatVector<double> partsol (dofs.Size (), lh);
               calculateParticularSolution<double> (
                   partsol, lfis, *fes_test, element_id, *ma, elmat_T_inv, lh);
@@ -966,6 +988,57 @@ namespace ngcomp
     return particular_solution_vec;
   }
 
+  shared_ptr<const BaseVector> TrefftzEmbedding::GetParticularSolution (
+      shared_ptr<const BaseVector> _trhsvec) const
+  {
+    LocalHeap clh = LocalHeap (100 * 1000 * 1000, "embt_psol", true);
+
+    shared_ptr<BaseVector> particular_solution_vec;
+    if (fes->IsComplex ())
+      particular_solution_vec
+          = make_shared<VVector<Complex>> (fes->GetNDof ());
+    else
+      particular_solution_vec = make_shared<VVector<double>> (fes->GetNDof ());
+    particular_solution_vec->operator= (0.0);
+
+    ma->IterateElements (
+        VOL, clh, [&] (Ngs_Element mesh_element, LocalHeap &lh) {
+          if (fes->IsComplex () && !etmatsc[mesh_element.Nr ()])
+            return;
+          if (!fes->IsComplex () && !etmats[mesh_element.Nr ()])
+            return;
+          const ElementId element_id = ElementId (mesh_element);
+
+          Array<DofId> dofs, dofs_test;
+          fes->GetDofNrs (element_id, dofs, VISIBLE_DOF);
+          if (ignoredofs)
+            for (size_t i = 0; i < dofs.Size (); i++)
+              if (ignoredofs->Test (dofs[i]))
+                dofs.RemoveElement (i);
+          fes_test->GetDofNrs (element_id, dofs_test, VISIBLE_DOF);
+
+          if (fes->IsComplex ())
+            {
+              auto 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);
+              partsol = elmat_T_inv * elvec;
+              particular_solution_vec->SetIndirect (dofs, partsol);
+            }
+          else
+            {
+              auto 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);
+              partsol = elmat_T_inv * elvec;
+              particular_solution_vec->SetIndirect (dofs, partsol);
+            }
+        });
+    return particular_solution_vec;
+  }
+
   shared_ptr<const BaseMatrix> TrefftzEmbedding::GetEmbedding () const
   {
     if (fes->IsComplex ())
@@ -990,6 +1063,9 @@ namespace ngcomp
         createConformingTrefftzTables (table, table2, etmatsc,
                                        local_ndofs_trefftz, *fes,
                                        fes_conformity, ignoredofs);
+        for (size_t i = 0; i < etmatsc.Size (); i++)
+          if (etmatsc[i])
+            QuickSort (table2[i]);
       }
     else
       {
@@ -997,6 +1073,9 @@ namespace ngcomp
         createConformingTrefftzTables (table, table2, etmats,
                                        local_ndofs_trefftz, *fes,
                                        fes_conformity, ignoredofs);
+        for (size_t i = 0; i < etmats.Size (); i++)
+          if (etmats[i])
+            QuickSort (table2[i]);
       }
     if (fes_conformity)
       vec->SetScalar (0.0);
@@ -1066,21 +1145,21 @@ namespace ngcomp
     if (!this->IsComplex ())
       {
         Table<DofId> _table_dummy{};
-        createConformingTrefftzTables (_table_dummy, elnr_to_dofs, etmats,
-                                       emb->GetLocalNodfsTrefftz (), *fes,
-                                       fes_conformity, ignoredofs);
-        for (size_t i = 0; i < etmats.Size (); i++)
-          if (etmats[i])
+        createConformingTrefftzTables (
+            _table_dummy, elnr_to_dofs, emb->GetEtmats (),
+            emb->GetLocalNodfsTrefftz (), *fes, fes_conformity, ignoredofs);
+        for (size_t i = 0; i < emb->GetEtmats ().Size (); i++)
+          if (emb->GetEtmat (i))
             QuickSort (elnr_to_dofs[i]);
       }
     else
       {
         Table<DofId> _table_dummy{};
-        createConformingTrefftzTables (_table_dummy, elnr_to_dofs, etmatsc,
-                                       emb->GetLocalNodfsTrefftz (), *fes,
-                                       fes_conformity, ignoredofs);
-        for (size_t i = 0; i < etmatsc.Size (); i++)
-          if (etmatsc[i])
+        createConformingTrefftzTables (
+            _table_dummy, elnr_to_dofs, emb->GetEtmatsC (),
+            emb->GetLocalNodfsTrefftz (), *fes, fes_conformity, ignoredofs);
+        for (size_t i = 0; i < emb->GetEtmatsC ().Size (); i++)
+          if (emb->GetEtmatC (i))
             QuickSort (elnr_to_dofs[i]);
       }
 
@@ -1093,8 +1172,8 @@ namespace ngcomp
     for (auto ei : this->ma->Elements (VOL))
       {
         // skip this element, if there is no element matrix defined
-        if ((this->IsComplex () && !etmatsc[ei.Nr ()])
-            || (!this->IsComplex () && !etmats[ei.Nr ()]))
+        if ((this->IsComplex () && !emb->GetEtmatC (ei.Nr ()))
+            || (!this->IsComplex () && !emb->GetEtmat (ei.Nr ())))
           continue;
 
         const size_t ndof_trefftz_local
@@ -1160,6 +1239,34 @@ namespace ngcomp
         }
   }
 
+  template <typename T>
+  optional<FlatMatrix<double>>
+  EmbTrefftzFESpace<T>::GetEtmatInv (size_t idx) const
+  {
+    std::call_once (this->etmats_inv_computed, [&] () {
+      this->fes->GetMeshAccess ()->IterateElements (VOL, [&] (ElementId ei) {
+        optional<Matrix<double>> etmat = emb->GetEtmat (ei.Nr ());
+        this->etmats_inv[ei.Nr ()]
+            = (etmat) ? make_optional (getPseudoInverse (*etmat, 0)) : nullopt;
+      });
+    });
+    return this->etmats_inv[idx];
+  }
+
+  template <typename T>
+  optional<FlatMatrix<Complex>>
+  EmbTrefftzFESpace<T>::GetEtmatCInv (size_t idx) const
+  {
+    std::call_once (this->etmats_inv_computed, [&] () {
+      this->fes->GetMeshAccess ()->IterateElements (VOL, [&] (ElementId ei) {
+        optional<Matrix<Complex>> etmat = emb->GetEtmatC (ei.Nr ());
+        this->etmatsc_inv[ei.Nr ()]
+            = (etmat) ? make_optional (getPseudoInverse (*etmat, 0)) : nullopt;
+      });
+    });
+    return this->etmatsc_inv[idx];
+  }
+
   /// double/complex generic implementation for the methods VTransformM(R | C)
   /// for the embedded Trefftz FESpace.
   template <typename SCAL>
@@ -1204,7 +1311,7 @@ namespace ngcomp
   EmbTrefftzFESpace<T>::VTransformMR (ElementId ei, SliceMatrix<double> mat,
                                       TRANSFORM_TYPE type) const
   {
-    const auto elmat = *etmats[ei.Nr ()];
+    const auto elmat = *(emb->GetEtmat (ei.Nr ()));
     etFesVTransformM (mat, type, elmat);
   }
 
@@ -1213,16 +1320,16 @@ namespace ngcomp
   EmbTrefftzFESpace<T>::VTransformMC (ElementId ei, SliceMatrix<Complex> mat,
                                       TRANSFORM_TYPE type) const
   {
-    const auto elmat = *etmatsc[ei.Nr ()];
+    const auto elmat = *(emb->GetEtmatC (ei.Nr ()));
     etFesVTransformM (mat, type, elmat);
   }
 
   /// double/complex generic implementation for the methods VTransformV(R | C)
   /// for the embedded Trefftz FESpace.
   template <typename SCAL>
-  void
-  etFesVTransformV (SliceVector<SCAL> &vec, const TRANSFORM_TYPE type,
-                    const Matrix<SCAL> &elmat, const Matrix<SCAL> &elmat_inv)
+  void etFesVTransformV (SliceVector<SCAL> &vec, const TRANSFORM_TYPE type,
+                         const Matrix<SCAL> &elmat,
+                         optional<FlatMatrix<SCAL>> elmat_inv)
   {
     const size_t ndof = elmat.Width ();
 
@@ -1246,8 +1353,8 @@ namespace ngcomp
               "given vec does not match the needed dimension.");
 
         // const auto elmat_inv = getPseudoInverse (elmat, 0);
-        Vector<SCAL> tmp_vec (elmat_inv.Height ());
-        tmp_vec = elmat_inv * vec;
+        Vector<SCAL> tmp_vec ((*elmat_inv).Height ());
+        tmp_vec = (*elmat_inv) * vec;
         vec = tmp_vec;
       }
     else
@@ -1266,8 +1373,10 @@ namespace ngcomp
     static Timer timer ("EmbTrefftz: VTransform");
     RegionTimer reg (timer);
 
-    etFesVTransformV (vec, type, *this->etmats[ei.Nr ()],
-                      *this->etmats_inv[ei.Nr ()]);
+    etFesVTransformV (vec, type, *(emb->GetEtmat (ei.Nr ())),
+                      (type == TRANSFORM_SOL_INVERSE)
+                          ? this->GetEtmatInv (ei.Nr ())
+                          : nullopt);
   }
 
   template <typename T>
@@ -1278,8 +1387,10 @@ namespace ngcomp
     static Timer timer ("EmbTrefftz: VTransform");
     RegionTimer reg (timer);
 
-    etFesVTransformV (vec, type, *this->etmatsc[ei.Nr ()],
-                      *this->etmatsc_inv[ei.Nr ()]);
+    etFesVTransformV (vec, type, *(emb->GetEtmatC (ei.Nr ())),
+                      (type == TRANSFORM_SOL_INVERSE)
+                          ? this->GetEtmatCInv (ei.Nr ())
+                          : nullopt);
   }
 
   // template class EmbTrefftzFESpace<L2HighOrderFESpace,
@@ -1307,6 +1418,9 @@ template <typename T> void ExportETSpace (py::module m, string label)
   auto pyspace
       = ngcomp::ExportFESpace<ngcomp::EmbTrefftzFESpace<T>> (m, label);
 
+  pyspace.def ("GetEmbedding", &ngcomp::EmbTrefftzFESpace<T>::GetEmbedding,
+               "Get the TrefftzEmbedding");
+
   // pyspace.def (py::init ([pyspace] (shared_ptr<T> fes) {
   // py::list info;
   // auto ma = fes->GetMeshAccess ();
@@ -1372,11 +1486,30 @@ void ExportEmbTrefftz (py::module m)
                 at best dim(fes)-dim(fes_test) and may increase by zero singular values of `top`
                 (with respect to the threshold `eps`).
             )mydelimiter")
-      .def (py::init<shared_ptr<SumOfIntegrals>, shared_ptr<SumOfIntegrals>,
-                     shared_ptr<SumOfIntegrals>, shared_ptr<SumOfIntegrals>,
-                     size_t, double, shared_ptr<FESpace>, shared_ptr<FESpace>,
-                     shared_ptr<FESpace>, shared_ptr<BitArray>> (),
-            R"mydelimiter(
+      .def (
+          // could be py::init<..,optional<py::dict>>() but we translate to map
+          py::init ([] (shared_ptr<SumOfIntegrals> top,
+                        shared_ptr<SumOfIntegrals> trhs,
+                        shared_ptr<SumOfIntegrals> cop,
+                        shared_ptr<SumOfIntegrals> crhs, size_t ndof_trefftz,
+                        double eps, shared_ptr<FESpace> fes,
+                        shared_ptr<FESpace> fes_test,
+                        shared_ptr<FESpace> fes_conformity,
+                        shared_ptr<BitArray> ignoredofs,
+                        optional<py::dict> pystats) {
+            shared_ptr<std::map<std::string, Vector<double>>> stats = nullptr;
+            if (pystats)
+              stats = make_shared<std::map<std::string, Vector<double>>> ();
+            std::shared_ptr<TrefftzEmbedding> emb
+                = std::make_shared<TrefftzEmbedding> (
+                    top, trhs, cop, crhs, ndof_trefftz, eps, fes, fes_test,
+                    fes_conformity, ignoredofs, stats);
+            if (pystats)
+              for (auto const &x : *stats)
+                (*pystats)[py::cast (x.first)] = py::cast (x.second);
+            return emb;
+          }),
+          R"mydelimiter(
                 Constructs a new Trefftz embedding object.
 
                  :param top: the differential operation. Can be None
@@ -1397,12 +1530,13 @@ void ExportEmbTrefftz (py::module m)
                  :param fes_conformity: finite element space of the conformity operation (optional,
                      determined from `cop` if not given)
             )mydelimiter",
-            py::arg ("top") = nullptr, py::arg ("trhs") = nullptr,
-            py::arg ("cop") = nullptr, py::arg ("crhs") = nullptr,
-            py::arg ("ndof_trefftz") = 0, py::arg ("eps") = 0.0,
-            py::arg ("fes") = nullptr, py::arg ("fes_test") = nullptr,
-            py::arg ("fes_conformity") = nullptr,
-            py::arg ("ignoredofs") = nullptr)
+          py::arg ("top") = nullptr, py::arg ("trhs") = nullptr,
+          py::arg ("cop") = nullptr, py::arg ("crhs") = nullptr,
+          py::arg ("ndof_trefftz") = 0, py::arg ("eps") = 0.0,
+          py::arg ("fes") = nullptr, py::arg ("fes_test") = nullptr,
+          py::arg ("fes_conformity") = nullptr,
+          py::arg ("ignoredofs") = nullptr,
+          py::arg ("stats") = nullopt) // py::none ())
       .def ("Embed", &ngcomp::TrefftzEmbedding::Embed,
             "Embed a Trefftz GridFunction into the underlying FESpace")
       .def ("GetEmbedding", &ngcomp::TrefftzEmbedding::GetEmbedding,
@@ -1418,7 +1552,13 @@ void ExportEmbTrefftz (py::module m)
                 shared_ptr<SumOfIntegrals>) const> (
                 &ngcomp::TrefftzEmbedding::GetParticularSolution),
             "Particular solution as GridFunction vector of the underlying "
-            "FESpace, given a trhs");
+            "FESpace, given a trhs")
+      .def ("GetParticularSolution",
+            static_cast<shared_ptr<const BaseVector> (TrefftzEmbedding::*) (
+                shared_ptr<const BaseVector>) const> (
+                &ngcomp::TrefftzEmbedding::GetParticularSolution),
+            "Particular solution as GridFunction vector of the underlying "
+            "FESpace, given a trhs as vector");
 }
 
 #endif // NGS_PYTHON