ngsolve 6.2.2502__cp312-cp312-macosx_10_15_universal2.whl → 6.2.2504__cp312-cp312-macosx_10_15_universal2.whl

netgen/include/fespace.hpp

@@ -256,7 +256,7 @@ ANY                  1 1 1 1 | 15
 
     virtual void UpdateDofTables() { ; } 
     virtual void UpdateCouplingDofArray() { ; } 
-
+    virtual void UpdateFreeDofs();
     /// update element coloring
     virtual void FinalizeUpdate();
 
@@ -640,7 +640,7 @@ ANY                  1 1 1 1 | 15
     /// Set multigrid prolongation
     // void SetProlongation (ngmg::Prolongation * aprol)
     // { prol = aprol; }
-    virtual void SetHarmonicProlongation (shared_ptr<BilinearForm> bfa);
+    virtual void SetHarmonicProlongation (shared_ptr<BilinearForm> bfa, string inverse);
 
     /// returns function-evaluator
     shared_ptr<DifferentialOperator> GetEvaluator (VorB vb = VOL) const
@@ -1109,6 +1109,7 @@ ANY                  1 1 1 1 | 15
 
     /// copies dofcoupling from components
     void UpdateCouplingDofArray() override;
+    virtual void UpdateFreeDofs() override;
     
     void SetDefinedOn (VorB vb, const BitArray& defon) override;
 

netgen/include/integrator.hpp

@@ -781,20 +781,14 @@ namespace ngfem
                         const FiniteElement & volumefel2, int LocalFacetNr2,
                         const ElementTransformation & eltrans2, FlatArray<int> & ElVertices2,
                         FlatVector<double> elx, FlatVector<double> ely,
-                        LocalHeap & lh) const
-    { 
-      throw Exception ("FacetBilinearFormIntegrator::ApplyFacetMatrix for inner facets not implemented!");
-    }
+                        LocalHeap & lh) const;
     virtual void
       ApplyFacetMatrix (const FiniteElement & volumefel1, int LocalFacetNr1,
                         const ElementTransformation & eltrans1, FlatArray<int> & ElVertices1,
                         const FiniteElement & volumefel2, int LocalFacetNr2,
                         const ElementTransformation & eltrans2, FlatArray<int> & ElVertices2,
                         FlatVector<Complex> elx, FlatVector<Complex> ely,
-                        LocalHeap & lh) const
-    { 
-      throw Exception ("FacetBilinearFormIntegrator::ApplyFacetMatrix for inner facets not implemented!");
-    }
+                        LocalHeap & lh) const;
 
 
     virtual void
@@ -841,19 +835,13 @@ namespace ngfem
                         const ElementTransformation & eltrans, FlatArray<int> & ElVertices,
                         const ElementTransformation & seltrans, FlatArray<int> & SElVertices,
                         FlatVector<double> elx, FlatVector<double> ely,
-                        LocalHeap & lh) const
-    { 
-      throw Exception ("FacetBilinearFormIntegrator::ApplyFacetMatrix for boundary facets not implemented!");
-    }
+                        LocalHeap & lh) const;
     virtual void
       ApplyFacetMatrix (const FiniteElement & volumefel, int LocalFacetNr,
                         const ElementTransformation & eltrans, FlatArray<int> & ElVertices,
                         const ElementTransformation & seltrans, FlatArray<int> & SElVertices,
                         FlatVector<Complex> elx, FlatVector<Complex> ely,
-                        LocalHeap & lh) const
-    { 
-      throw Exception ("FacetBilinearFormIntegrator::ApplyFacetMatrix for boundary facets not implemented!");
-    }
+                        LocalHeap & lh) const;
 
 
     // calculate traces in integration points

netgen/include/intrules_SauterSchwab.hpp

@@ -0,0 +1,25 @@
+#ifndef INTRULES_HPP
+#define INTRULES_HPP
+
+#include <bla.hpp>
+
+namespace ngsbem
+{
+  using namespace ngbla;
+  
+  // x, y in triangle [(0,0), (1,0), (0,1)]
+  tuple<Array<Vec<2>>, Array<Vec<2>>, Array<double>> IdenticPanelIntegrationRule (int order);
+
+
+  // x, y in triangle [(0,0), (1,0), (0,1)]
+  // x=(0,0) and y=(0,0) are common vertices
+  tuple<Array<Vec<2>>, Array<Vec<2>>, Array<double>> CommonVertexIntegrationRule (int order);
+  
+
+  // x, y in triangle [(0,0), (1,0), (0,1)]
+  // x in [(0,0),(1,0)] and y in [(0,0),(1,0)] are common edges
+  tuple<Array<Vec<2>>, Array<Vec<2>>, Array<double>> CommonEdgeIntegrationRule (int order);
+  
+}
+
+#endif

netgen/include/mp_coefficient.hpp

@@ -0,0 +1,140 @@
+#ifndef MP_COEFFICIENT
+#define MP_COEFFICIENT
+
+
+#include "mptools.hpp"
+
+namespace ngsbem
+{
+
+  
+  // ******************** Coefficient Functions *********************
+
+  
+  class SphericalHarmonicsCF : public CoefficientFunction
+  {
+    SphericalHarmonics<Complex> sh;
+  public:
+    SphericalHarmonicsCF (int order)
+      : CoefficientFunction(1, true), sh(order) { }
+    Complex & Coef(int n, int m) { return sh.Coef(n,m); } 
+    
+    virtual double Evaluate (const BaseMappedIntegrationPoint & ip) const override
+    { throw Exception("real eval not available"); }
+
+    virtual void Evaluate (const BaseMappedIntegrationPoint & mip, FlatVector<Complex> values) const override
+    {
+      values(0) = sh.Eval(mip.GetPoint());
+    }
+    
+    virtual void Evaluate (const BaseMappedIntegrationRule & ir, BareSliceMatrix<Complex> values) const override
+    {
+      for (int i = 0; i < ir.Size(); i++)
+        {
+          auto & mip = ir[i];
+          values(i,0) = sh.Eval(mip.GetPoint());
+        }
+    }
+
+    auto & SH() { return sh; }
+  };
+
+
+
+  template <typename entry_type> class RegularMLMultiPoleCF;
+  
+
+  template <typename RADIAL, typename entry_type=Complex>
+  class MultiPoleCF : public CoefficientFunction
+  {
+    MultiPole<RADIAL, entry_type> mp;
+    Vec<3> center;
+  public:
+    MultiPoleCF (int order, double kappa, Vec<3> acenter, double rtyp = 1)
+      : CoefficientFunction(sizeof(entry_type)/sizeof(Complex), true), mp(order, kappa, rtyp), center(acenter) { }
+
+    entry_type & Coef(int n, int m) { return mp.Coef(n,m); } 
+    auto & SH() { return mp.SH(); }
+    auto & MP() { return mp; }
+    Vec<3> Center() const { return center; }
+    
+    virtual double Evaluate (const BaseMappedIntegrationPoint & ip) const override
+    { throw Exception("real eval not available"); }
+
+    virtual void Evaluate (const BaseMappedIntegrationPoint & mip, FlatVector<Complex> values) const override
+    {
+      if constexpr (std::is_same<entry_type, Complex>())
+        values(0) = mp.Eval(mip.GetPoint()-center);
+      else
+        values = mp.Eval(mip.GetPoint()-center);
+    }
+
+    template <typename TARGET>
+    void ShiftZ (double z, MultiPole<TARGET, entry_type> & target) { mp.ShiftZ(z, target); }
+
+    using CoefficientFunction::Transform;        
+    template <typename TARGET>
+    void Transform (MultiPoleCF<TARGET, entry_type> & target)
+    {
+      mp.Transform (target.MP(), target.Center()-center);
+    }
+  };
+
+  template <typename entry_type>
+  class SingularMLMultiPoleCF : public CoefficientFunction
+  {
+    shared_ptr<SingularMLMultiPole<entry_type>> mlmp;
+  public:
+    SingularMLMultiPoleCF (Vec<3> center, double r, double kappa)
+      : CoefficientFunction(sizeof(entry_type)/sizeof(Complex), true), mlmp{make_shared<SingularMLMultiPole<entry_type>>(center, r, kappa)} { }
+    
+    virtual double Evaluate (const BaseMappedIntegrationPoint & ip) const override
+    { throw Exception("real eval not available"); }
+    
+    virtual void Evaluate (const BaseMappedIntegrationPoint & mip, FlatVector<Complex> values) const override
+    {
+      // values(0) = mlmp->Evaluate(mip.GetPoint());
+
+      if constexpr (std::is_same<entry_type, Complex>())
+        values(0) = mlmp->Evaluate(mip.GetPoint());
+      else
+        values = mlmp->Evaluate(mip.GetPoint());
+
+      
+    }
+    
+    shared_ptr<SingularMLMultiPole<entry_type>> MLMP() const { return mlmp; }
+    shared_ptr<RegularMLMultiPoleCF<entry_type>> CreateRegularExpansion(Vec<3> center, double r) const;
+  };
+  
+
+  template <typename entry_type>
+  class RegularMLMultiPoleCF : public CoefficientFunction
+  {
+    shared_ptr<RegularMLMultiPole<entry_type>> mlmp;
+  public:
+    RegularMLMultiPoleCF (shared_ptr<SingularMLMultiPoleCF<entry_type>> asingmp, Vec<3> center, double r)
+      : CoefficientFunction(sizeof(entry_type)/sizeof(Complex), true), mlmp{make_shared<RegularMLMultiPole<entry_type>>(asingmp->MLMP(), center, r)} { } 
+    RegularMLMultiPoleCF (shared_ptr<SingularMLMultiPole<entry_type>> asingmp, Vec<3> center, double r)
+      : CoefficientFunction(sizeof(entry_type)/sizeof(Complex), true), mlmp{make_shared<RegularMLMultiPole<entry_type>>(asingmp, center, r)} { } 
+    
+    virtual double Evaluate (const BaseMappedIntegrationPoint & ip) const override
+    { throw Exception("real eval not available"); }
+
+    virtual void Evaluate (const BaseMappedIntegrationPoint & mip, FlatVector<Complex> values) const override
+    {
+      // values(0) = mlmp->Evaluate(mip.GetPoint());
+
+      if constexpr (std::is_same<entry_type, Complex>())
+        values(0) = mlmp->Evaluate(mip.GetPoint());
+      else
+        values = mlmp->Evaluate(mip.GetPoint());
+    }
+
+    shared_ptr<RegularMLMultiPole<entry_type>> MLMP() { return mlmp; }
+  };
+
+  
+}
+
+#endif