ngsolve 6.2.2506.post75.dev0__cp314-cp314-manylinux_2_28_x86_64.whl

ngsolve-6.2.2506.post75.dev0.data/data/include/netgen/prolongation.hpp

@@ -0,0 +1,377 @@
+#ifndef FILE_PROLONGATION
+#define FILE_PROLONGATION
+
+/*********************************************************************/
+/* File:   prolongation.hh                                           */
+/* Author: Joachim Schoeberl                                         */
+/* Date:   20. Apr. 2000                                             */
+/*********************************************************************/
+
+namespace ngcomp { class NedelecFESpace; }
+namespace ngla { class SparseFactorization; } 
+namespace ngmg
+{
+
+  /** 
+      Grid Transfer operators
+  */
+  class NGS_DLL_HEADER Prolongation
+  {
+    Array<DofRange> leveldofs;
+    
+  public:
+    ///
+    Prolongation();
+    ///
+    virtual ~Prolongation();
+  
+    ///
+    virtual void Update (const FESpace & fes);
+    virtual size_t GetNDofLevel (int level) { throw Exception("Prolongation::GetNDofLevel not overloaded"); }
+    DofRange LevelDofs (int level) const;
+
+    ///
+    virtual shared_ptr<SparseMatrix< double >> CreateProlongationMatrix( int finelevel ) const = 0;
+    ///
+    virtual void ProlongateInline (int finelevel, BaseVector & v) const = 0;
+    ///
+    virtual void RestrictInline (int finelevel, BaseVector & v) const = 0;
+
+    virtual shared_ptr<BitArray> GetInnerDofs (int finelevel) const { return nullptr; }
+  };
+
+
+  class ProlongationOperator : public BaseMatrix
+  {
+    shared_ptr<Prolongation> prol;
+    int level;
+  public:
+    ProlongationOperator (shared_ptr<Prolongation> aprol, int alevel)
+      : prol(aprol), level(alevel) { } 
+
+    virtual bool IsComplex() const override { return false; } 
+
+    virtual int VHeight() const override { return prol->GetNDofLevel(level); }
+    virtual int VWidth() const override { return prol->GetNDofLevel(level-1); }
+
+    virtual void Mult (const BaseVector & x, BaseVector & y) const override
+    {
+      y.Range(0, VWidth()) = x;
+      prol->ProlongateInline (level, y);
+    }
+    virtual void MultTrans (const BaseVector & x, BaseVector & y) const override
+    {
+      auto tmp = x.CreateVector();
+      tmp = x;
+      prol->RestrictInline (level, tmp);
+      y = tmp.Range(0, VWidth());
+    }
+
+    AutoVector CreateRowVector() const override { return make_unique<VVector<double>> (VWidth()); }
+    AutoVector CreateColVector() const override { return make_unique<VVector<double>> (VHeight()); }
+  };
+  
+
+
+  
+  /**
+     Standard Prolongation.
+     Child nodes between 2 parent nodes.
+  */
+  class LinearProlongation : public Prolongation
+  {
+    shared_ptr<MeshAccess> ma;
+    Array<size_t> nvlevel;
+    bool allow_parallel = true;
+  public:
+    LinearProlongation(shared_ptr<MeshAccess> ama)
+      : ma(ama) { ; }
+    
+    virtual ~LinearProlongation(); 
+
+    virtual void Update (const FESpace & fes) override;
+    virtual size_t GetNDofLevel (int level) override { return nvlevel[level]; }
+    
+    virtual shared_ptr<SparseMatrix< double >> CreateProlongationMatrix( int finelevel ) const override;
+    virtual void ProlongateInline (int finelevel, BaseVector & v) const override;
+    virtual void RestrictInline (int finelevel, BaseVector & v) const override;
+  };
+
+
+  /*
+  /// Prolongation for non-conforming P1 triangle.
+  class NonConformingProlongation : public Prolongation
+  {
+    ///
+    shared_ptr<MeshAccess> ma;
+    ///
+    const NonConformingFESpace & space;
+  public:
+    ///
+    NonConformingProlongation(shared_ptr<MeshAccess> ama,
+			      const NonConformingFESpace & aspace);
+    ///
+    virtual ~NonConformingProlongation();
+  
+    ///
+    virtual void Update ();
+
+    ///
+    virtual SparseMatrix< double >* CreateProlongationMatrix( int finelevel ) const
+    { return NULL; }
+    ///
+    virtual void ProlongateInline (int finelevel, BaseVector & v) const;
+    ///
+    virtual void RestrictInline (int finelevel, BaseVector & v) const;
+  };
+  */
+
+
+  /// Piecewise constant prolongaton.
+  class ElementProlongation : public Prolongation
+  {
+    ///
+    shared_ptr<MeshAccess> ma;
+    ///
+    const FESpace & space;
+    VorB vb;
+  public:
+    ///
+    ElementProlongation(const FESpace & aspace, VorB avb = VOL);
+
+    virtual ~ElementProlongation();
+  
+    ///
+    virtual void Update (const FESpace & fes) override;
+
+    virtual shared_ptr<SparseMatrix< double >> CreateProlongationMatrix( int finelevel ) const override;
+
+    ///
+    virtual void ProlongateInline (int finelevel, BaseVector & v) const override;
+    virtual void RestrictInline (int finelevel, BaseVector & v) const override;
+  };
+
+
+
+
+  /// Prolongation for edge-elements.
+  // template <class TV>
+  class EdgeProlongation : public Prolongation
+  {
+    ///
+    shared_ptr<MeshAccess> ma;
+    ///
+    const NedelecFESpace & space;
+  public:
+    ///
+    EdgeProlongation(const NedelecFESpace & aspace);
+    ///
+    virtual ~EdgeProlongation() { ; }
+  
+    ///
+    virtual void Update (const FESpace & fes) override { ; }
+
+    ///
+    virtual shared_ptr<SparseMatrix< double >> CreateProlongationMatrix( int finelevel ) const override
+    { return NULL; }
+
+    ///
+    virtual void ProlongateInline (int finelevel, BaseVector & v) const override;
+    virtual void RestrictInline (int finelevel, BaseVector & v) const override;
+
+    ///
+    void ApplyGradient (int level, const BaseVector & pot, BaseVector & grad) const 
+    {
+      cout << "apply grad" << endl;
+    }
+  };
+
+
+
+
+  /// Product space prolongation, combination of elementary prolongations 
+  class NGS_DLL_HEADER CompoundProlongation : public Prolongation
+  {
+  protected:
+    ///
+    const CompoundFESpace * space;
+    ///
+    Array<shared_ptr<Prolongation>> prols;
+  public:
+    ///
+    CompoundProlongation(const CompoundFESpace * aspace);
+    ///
+    CompoundProlongation(const CompoundFESpace * aspace,
+			 Array<shared_ptr<Prolongation>> & aprols);
+    ///
+    virtual ~CompoundProlongation();
+    // { ; }
+  
+    ///
+    virtual void Update (const FESpace & fes) override;
+    virtual size_t GetNDofLevel (int level) override;
+    
+    virtual shared_ptr<BitArray> GetInnerDofs (int finelevel) const override;
+
+    void AddProlongation (shared_ptr<Prolongation> prol)
+    {
+      prols.Append (prol);
+    }
+
+    ///
+    virtual shared_ptr<SparseMatrix< double >> CreateProlongationMatrix( int finelevel ) const override
+    { return NULL; }
+
+
+    ///
+    virtual void ProlongateInline (int finelevel, BaseVector & v) const override;
+
+    ///
+    virtual void RestrictInline (int finelevel, BaseVector & v) const override;
+  };
+
+  class NGS_DLL_HEADER HarmonicProlongation : public Prolongation
+  {
+    shared_ptr<Prolongation> baseprol;
+    weak_ptr<BilinearForm> wbfa;
+    Array<shared_ptr<BaseMatrix>> innerinverses;
+    Array<size_t> facets_on_level;
+    Array<shared_ptr<BitArray>> freedofs;
+    string inverse;
+  public:
+    HarmonicProlongation (shared_ptr<Prolongation> abaseprol,
+                          shared_ptr<BilinearForm> abfa, string ainverse);
+
+    virtual void Update (const FESpace & fes) override;
+    
+    virtual size_t GetNDofLevel (int level) override { return baseprol->GetNDofLevel(level); } 
+
+    virtual shared_ptr<SparseMatrix< double >> CreateProlongationMatrix( int finelevel ) const override;
+    virtual void ProlongateInline (int finelevel, BaseVector & v) const override;
+    virtual void RestrictInline (int finelevel, BaseVector & v) const override;
+  };
+
+
+
+
+  
+  template <int DIM>
+  class FacetProlongation : public Prolongation
+  {
+  protected:
+    shared_ptr<MeshAccess> ma;
+    
+    int dofs_per_facet = -1;
+    Array<Array<int>> first_dofs;
+    Array<int> prol_class;  // which prol to use ?
+    Array<size_t> facets_on_level;
+
+    static constexpr int NUMPROL = (DIM==2) ? 2 : 32;
+    array<Matrix<double>,NUMPROL> facetprol;
+    
+    bool haveprols = false;
+    
+  public:
+    FacetProlongation (shared_ptr<MeshAccess> ama)
+      : ma(ama) { }
+
+
+    virtual shared_ptr<SparseMatrix< double >> CreateProlongationMatrix( int finelevel ) const override
+    {
+      return nullptr;  // or NULL ? 
+    }
+
+    
+    virtual void ProlongateInline (int finelevel, BaseVector & v) const override
+    {
+      auto fv = v.FV<double>();
+      Matrix<double> tmp(facets_on_level[finelevel], dofs_per_facet);
+      tmp = 0.0;
+      
+      for (size_t i = 0; i < first_dofs[finelevel-1].Size()-1; i++)
+        {
+          IntRange r(first_dofs[finelevel-1][i], first_dofs[finelevel-1][i+1]);
+          if (r.Size() > 0)
+            tmp.Row(i) = fv.Range(r);
+        }
+
+      if constexpr (DIM==2)
+        {
+          for (int i = facets_on_level[finelevel-1]; i < facets_on_level[finelevel]; i++)
+            if (auto parents = get<1>(ma->GetParentEdges(i)); parents[1] == -1)
+              {
+                int pe = parents[0];
+                tmp.Row(i) = facetprol[prol_class[i]] * tmp.Row(pe);
+              }
+        }
+      else
+        {
+          for (int i = facets_on_level[finelevel-1]; i < facets_on_level[finelevel]; i++)
+          if (auto parents = get<1>(ma->GetParentFaces(i)); parents[1] == -1)
+            {
+              int pe = parents[0];
+              tmp.Row(i) = facetprol[prol_class[i]] * tmp.Row(pe);
+            }
+        }
+      
+      for (size_t i = 0; i < first_dofs[finelevel].Size()-1; i++)
+        {
+          IntRange r(first_dofs[finelevel][i], first_dofs[finelevel][i+1]);
+          if (r.Size() > 0)
+            fv.Range(r) = tmp.Row(i);
+        }
+    }
+    
+    virtual void RestrictInline (int finelevel, BaseVector & v) const override
+    {
+      auto fv = v.FV<double>();
+      Matrix<double> tmp(facets_on_level[finelevel], dofs_per_facet);
+      tmp = 0.0;
+      
+      for (size_t i = 0; i < first_dofs[finelevel].Size()-1; i++)
+        {
+          IntRange r(first_dofs[finelevel][i], first_dofs[finelevel][i+1]);
+          if (r.Size() > 0)
+            tmp.Row(i) = fv.Range(r);
+        }
+
+
+      if constexpr (DIM==2)
+        {
+          for (int i = facets_on_level[finelevel-1]; i < facets_on_level[finelevel]; i++)
+            if (auto parents = get<1>(ma->GetParentEdges(i)); parents[1] == -1)
+              {
+                int pe = parents[0];
+                tmp.Row(pe) += Trans(facetprol[prol_class[i]]) * tmp.Row(i);
+              }
+        }
+      else
+        {
+          // for (int i = facets_on_level[finelevel-1]; i < facets_on_level[finelevel]; i++)
+          for (int i = facets_on_level[finelevel]-1; i >= facets_on_level[finelevel-1]; i--)      
+            if (auto parents = get<1>(ma->GetParentFaces(i)); parents[1] == -1)
+              {
+                int pe = parents[0];
+                tmp.Row(pe) += Trans(facetprol[prol_class[i]]) * tmp.Row(i);
+                tmp.Row(i) = 0.0;  // optional, for testing
+              }
+        }
+      
+      fv = 0.0;
+      for (size_t i = 0; i < first_dofs[finelevel-1].Size()-1; i++)
+        {
+          IntRange r(first_dofs[finelevel-1][i], first_dofs[finelevel-1][i+1]);
+          if (r.Size() > 0)
+            fv.Range(r) = tmp.Row(i);
+        }
+
+    }
+    
+  };
+  
+  
+  
+}
+
+
+#endif

ngsolve-6.2.2506.post75.dev0.data/data/include/netgen/python_comp.hpp

@@ -0,0 +1,107 @@
+#ifndef NGSOLVE_PYTHON_COMP_HPP
+#define NGSOLVE_PYTHON_COMP_HPP
+
+#include <python_ngstd.hpp>
+#include <python_linalg.hpp>
+
+// #include "comp.hpp"
+
+#include "gridfunction.hpp"
+#include "periodic.hpp"
+
+namespace pybind11
+{
+  // specialized implementation of polymorphic_type_hook to allow
+  // unregistered derived types convert to registered derived types
+  // by trying to dynamic cast
+  template<>
+  struct polymorphic_type_hook<ngcomp::FESpace>
+  {
+    static const void* get(const ngcomp::FESpace* src, const type_info*& type)
+    {
+      // for example this could be a QuasiPeriodicFESpace<double>, ...
+      if(auto cast = dynamic_cast<const ngcomp::PeriodicFESpace*>(src))
+        {
+          type = &typeid(ngcomp::PeriodicFESpace);
+          return cast;
+        }
+      // if it's not one of these spaces use the default implementation
+      // for dynamic types
+      type = src ? &typeid(*src) : nullptr;
+      return dynamic_cast<const void*>(src);
+    }
+  };
+}
+
+namespace ngcomp
+{
+  // TODO: use Archive structure to pickle fespaces
+  inline py::tuple fesPickle (const FESpace& fes)
+  {
+    auto flags = fes.GetFlags();
+    auto mesh = fes.GetMeshAccess();
+    auto type = fes.type;
+    return py::make_tuple(type,mesh,flags);
+  }
+  
+  template<typename FESPACE>
+  shared_ptr<FESPACE> fesUnpickle(py::tuple state)
+  {
+    auto fes = CreateFESpace(state[0].cast<string>(),
+                             state[1].cast<shared_ptr<MeshAccess>>(),
+                             state[2].cast<Flags>());
+    fes->Update();
+    fes->FinalizeUpdate();
+    // MR: connect_auto_update?
+    return dynamic_pointer_cast<FESPACE>(fes);
+  };
+
+
+  inline void connect_auto_update(FESpace* fes) {
+    fes->ConnectAutoUpdate();
+  }
+
+  /*
+  inline void connect_auto_update(GridFunction* gf) {
+    gf->ConnectAutoUpdate();
+  }
+  */
+  
+  template <typename FES, typename BASE=FESpace>
+  auto ExportFESpace (py::module & m, string pyname, bool module_local = false)
+  {
+    auto docu = FES::GetDocu();
+    string docstring = docu.GetPythonDocString();
+    // string docuboth = docu.short_docu + "\n\n" + docu.long_docu;
+    auto pyspace = py::class_<FES, shared_ptr<FES>,BASE> (m, pyname.c_str(), docstring.c_str(), py::module_local(module_local));
+
+    pyspace
+      .def(py::init([pyspace](shared_ptr<MeshAccess> ma, py::kwargs kwargs)
+                    {
+                      py::list info;
+                      info.append(ma);
+                      auto flags = CreateFlagsFromKwArgs(kwargs, pyspace, info);
+                      auto fes = make_shared<FES>(ma,flags);
+                      fes->Update();
+                      fes->FinalizeUpdate();
+                      // connect_auto_update(fes.get());
+                      fes -> ConnectAutoUpdate();
+                      return fes;
+                    }),py::arg("mesh"))
+    
+      .def(py::pickle(&fesPickle,
+                      (shared_ptr<FES>(*)(py::tuple)) fesUnpickle<FES>))
+      ;
+
+    pyspace.def_static("__flags_doc__", [docu]()
+                                        {
+                                          py::dict flags_doc;
+                                          for (auto & flagdoc : FES::GetDocu().arguments)
+                                            flags_doc[get<0> (flagdoc).c_str()] = get<1> (flagdoc);
+                                          return flags_doc;
+                                         });
+    
+    return pyspace;
+  }
+}
+#endif // NGSOLVE_PYTHON_COMP_HPP

ngsolve-6.2.2506.post75.dev0.data/data/include/netgen/python_fem.hpp

@@ -0,0 +1,89 @@
+#ifndef PYTHON_FEM_HPP___
+#define PYTHON_FEM_HPP___
+#ifdef NGS_PYTHON
+
+#include <core/register_archive.hpp>
+// #include <fem.hpp>
+#include <coefficient.hpp>
+#include <finiteelement.hpp>
+
+namespace ngfem
+{
+  shared_ptr<CoefficientFunction> MakeCoefficient (py::object val);
+  Array<shared_ptr<CoefficientFunction>> MakeCoefficients (py::object py_coef);
+
+  template <typename FUNC>
+  void ExportStdMathFunction(py::module &m, string name, string description)
+  {
+    static RegisterClassForArchive<cl_UnaryOpCF<FUNC>, CoefficientFunction> reguopcf;
+
+    m.def (name.c_str(), [name] (py::object x) -> py::object
+              {
+                FUNC func;
+                py::extract<double> ed(x);
+                if (ed.check()) return py::cast(func(ed()));
+                if (py::extract<Complex> (x).check())
+                  return py::cast(func(py::extract<Complex> (x)()));
+                if (py::extract<shared_ptr<CoefficientFunction>>(x).check())
+                  {
+                    auto coef = py::extract<shared_ptr<CoefficientFunction>>(x)();
+                    return py::cast(UnaryOpCF(coef, func, FUNC::Name()));
+                  }
+                throw py::type_error (string("can't compute math-function, type = ")
+                                      + typeid(FUNC).name());
+              }, py::arg("x"), description.c_str());
+  }
+
+  template <typename FUNC>
+  void ExportStdMathFunction_(py::module &m, string name,
+                              string description)
+  {
+    static RegisterClassForArchive<cl_UnaryOpCF<FUNC>, CoefficientFunction> reguopcf;
+
+    m.def(name.c_str(), py::vectorize([](double x)
+    {
+        FUNC func;
+        return func(x);
+    }), py::arg("x"), description.c_str());
+    m.def(name.c_str(), py::vectorize([](Complex x)
+    {
+        FUNC func;
+        return func(x);
+    }), py::arg("x"), description.c_str());
+    m.def(name.c_str(), [] (shared_ptr<CoefficientFunction> x) -> shared_ptr<CoefficientFunction> {
+        FUNC func;
+        return func(x);
+      }, py::arg("x"), description.c_str());
+  }
+  
+
+  template <typename FUNC>
+  void ExportStdMathFunction2(py::module &m, string name, string description, string arg0="x", string arg1="y")
+  {
+    static RegisterClassForArchive<cl_BinaryOpCF<FUNC>, CoefficientFunction> regbinopcf;
+
+    m.def(name.c_str(), py::vectorize([](double x, double y)
+    {
+        FUNC func;
+        return func(x,y);
+    }), py::arg(arg0.c_str()), py::arg(arg1.c_str()), description.c_str());
+    m.def(name.c_str(), py::vectorize([](Complex x, Complex y)
+    {
+        FUNC func;
+        return func(x,y);
+    }), py::arg(arg0.c_str()), py::arg(arg1.c_str()), description.c_str());
+    m.def(name.c_str(),
+          [](shared_ptr<CoefficientFunction> x,
+             shared_ptr<CoefficientFunction> y)
+          -> shared_ptr<CoefficientFunction>
+    {
+      FUNC func;
+      return BinaryOpCF(x, y, func, FUNC::Name());
+    }, py::arg(arg0.c_str()), py::arg(arg1.c_str()), description.c_str());
+  }
+
+
+} // namespace ngfem
+
+#endif // NGS_PYTHON
+#endif // PYTHON_FEM_HPP___

ngsolve-6.2.2506.post75.dev0.data/data/include/netgen/python_linalg.hpp

@@ -0,0 +1,58 @@
+#ifndef NGSOLVE_PYTHON_LINALG_HPP
+#define NGSOLVE_PYTHON_LINALG_HPP
+
+#include <la.hpp>
+
+// Workaround to ensure same lifetime for C++ and Python objects
+// see https://github.com/pybind/pybind11/issues/1546
+namespace pybind11::detail {
+  using ngla::BaseMatrix;
+  template<>
+  struct type_caster<std::shared_ptr<BaseMatrix>>
+  {
+    PYBIND11_TYPE_CASTER (std::shared_ptr<BaseMatrix>, _("BaseMatrix"));
+
+    using BaseCaster = copyable_holder_caster<BaseMatrix, std::shared_ptr<BaseMatrix>>;
+
+    bool load (pybind11::handle src, bool b)
+    {
+      BaseCaster bc;
+      bool success = bc.load (src, b);
+      if (!success)
+      {
+        return false;
+      }
+
+      auto py_obj = reinterpret_borrow<object>(src);
+      auto base_ptr = static_cast<std::shared_ptr<BaseMatrix>> (bc);
+
+      // Construct a shared_ptr to the py::object
+      auto py_obj_ptr = std::shared_ptr<object>{
+          new object{py_obj},
+          [](object * py_object_ptr) {
+              // It's possible that when the shared_ptr dies we won't have the
+              // gil (if the last holder is in a non-Python thread), so we
+              // make sure to acquire it in the deleter.
+              gil_scoped_acquire gil;
+              delete py_object_ptr;
+         }
+      };
+
+      value = std::shared_ptr<BaseMatrix> (py_obj_ptr, base_ptr.get ());
+      return true;
+    }
+
+    static handle cast (std::shared_ptr<BaseMatrix> base,
+                        return_value_policy rvp,
+                        handle h)
+    {
+      return BaseCaster::cast (base, rvp, h);
+    }
+  };
+
+  template <>
+  struct is_holder_type<BaseMatrix, std::shared_ptr<BaseMatrix>> : std::true_type {};
+}
+
+#endif // NGSOLVE_PYTHON_LINALG_HPP
+