ngsolve 6.2.2506.post74.dev0__cp314-cp314-macosx_10_15_universal2.whl

netgen/include/mgpre.hpp

@@ -0,0 +1,204 @@
+
+#ifndef FILE_MGPRE
+#define FILE_MGPRE
+
+/*********************************************************************/
+/* File:   mgpre.hh                                                  */
+/* Author: Joachim Schoeberl                                         */
+/* Date:   20. Apr. 2000                                             */
+/*********************************************************************/
+
+#include <bilinearform.hpp>
+// #include <la.hpp>
+
+namespace ngmg
+{
+  using namespace ngla;
+  using namespace ngcomp;
+  using ngla::BaseMatrix;
+  
+  /** 
+      Multigrid preconditioner
+  */
+
+  class Smoother;
+  ///
+  class Prolongation;
+  
+
+  ///
+  class NGS_DLL_HEADER MultigridPreconditioner : public BaseMatrix
+  {
+
+  public:
+    enum COARSETYPE { EXACT_COARSE, CG_COARSE, SMOOTHING_COARSE, USER_COARSE };
+
+  private:
+    shared_ptr<BilinearForm> biform;
+    shared_ptr<MeshAccess> ma;
+  
+    shared_ptr<Smoother> smoother;
+    shared_ptr<Prolongation> prolongation;
+    shared_ptr<BaseMatrix> coarsegridpre;
+    
+    ///
+    double checksumcgpre;
+    ///
+    COARSETYPE coarsetype;
+    ///
+    int cycle, incsmooth, smoothingsteps;
+    ///
+    int coarsesmoothingsteps;
+    ///
+    int updateall;
+    /// creates a new smoother for each update
+    bool update_always; 
+    /// for robust prolongation
+    bool harmonic_extension_prolongation = false;
+    Array<shared_ptr<BaseMatrix>> he_prolongation;
+  public:
+    ///
+    MultigridPreconditioner (shared_ptr<BilinearForm> abiform,
+			     shared_ptr<Smoother> asmoother,
+			     shared_ptr<Prolongation> aprolongation);
+    ///
+    ~MultigridPreconditioner ();
+    ///
+    virtual bool IsComplex() const override
+    { return biform->GetFESpace()->IsComplex(); }
+
+    ///
+    void SetSmoothingSteps (int sstep);
+    ///
+    void SetCycle (int c);
+    ///
+    void SetIncreaseSmoothingSteps (int incsm);
+    ///
+    void SetCoarseType (COARSETYPE ctyp);
+    ///
+    void SetCoarseGridPreconditioner (shared_ptr<BaseMatrix> acoarsegridpre);
+    ///
+    void SetCoarseSmoothingSteps (int cstep);
+
+    void SetUpdateAll (int ua = 1);
+    ///
+    void SetUpdateAlways (bool ua = 1) { update_always = ua; }
+    ///
+    void SetHarmonicExtensionProlongation (bool he = true)
+    { harmonic_extension_prolongation = he; }
+    
+    ///
+    virtual void Update () override;
+
+    ///
+    virtual void Mult (const BaseVector & x, BaseVector & y) const override;
+
+    ///
+    void MGM (int level, BaseVector & u, 
+	      const BaseVector & f, int incsm = 1) const;
+    ///
+    AutoVector CreateRowVector () const override
+    { return biform->GetMatrix().CreateColVector(); }
+    AutoVector CreateColVector () const override
+    { return biform->GetMatrix().CreateRowVector(); }
+  
+    ///
+    const Smoother & GetSmoother() const
+    { return *smoother; }
+    ///
+    Smoother & GetSmoother()
+    { return *smoother; }
+    ///
+    const Prolongation & GetProlongation() const
+    { return *prolongation; }
+
+
+    virtual int VHeight() const override
+    {
+      return biform->GetMatrix().Height();
+    }
+
+    virtual int VWidth() const override
+    {
+      return biform->GetMatrix().VWidth();
+    }
+
+    virtual Array<MemoryUsage> GetMemoryUsage () const override;
+
+  private:
+    MemoryTracer mt = { "MultiGridPreconditioner" };
+  public:
+    const MemoryTracer& GetMemoryTracer() const { return mt; }
+  };
+
+
+
+
+
+
+
+  ///
+  class NGS_DLL_HEADER TwoLevelMatrix : public BaseMatrix
+  {
+    ///
+    const BaseMatrix * mat;
+    ///
+    const BaseMatrix * cpre;
+    ///
+    shared_ptr<Smoother> smoother;
+    shared_ptr<BaseMatrix> embedding;
+    ///
+    int level;
+    ///
+    int smoothingsteps;
+  public:
+    ///
+    TwoLevelMatrix (const BaseMatrix * amat, 
+		    const BaseMatrix * acpre, 
+		    shared_ptr<Smoother> asmoother, int alevel);
+    ///
+    ~TwoLevelMatrix ();
+
+    void SetEmbedding (shared_ptr<BaseMatrix> aembedding)
+    {
+      embedding = aembedding;
+    }
+    
+    virtual bool IsComplex() const override { return mat->IsComplex(); }
+
+    ///
+
+    virtual void Mult (const BaseVector & x, BaseVector & y) const override;
+    ///
+    AutoVector CreateRowVector () const override { return mat->CreateColVector(); }
+    AutoVector CreateColVector () const override { return mat->CreateRowVector(); }
+    ///
+    virtual ostream & Print (ostream & s) const override;
+    ///
+    void SetSmoothingSteps(int ass) { smoothingsteps = ass; }
+    ///
+    const Smoother & GetSmoother() const
+    { return *smoother; }
+    ///
+    Smoother & GetSmoother()
+    { return *smoother; }
+    ///
+    virtual void Update() override;
+
+    virtual int VHeight() const override
+    {
+      return mat->Height();
+    }
+
+    virtual int VWidth() const override
+    {
+      return mat->VWidth();
+    }
+  
+
+    virtual Array<MemoryUsage> GetMemoryUsage () const override;
+  };
+
+}
+
+#endif

netgen/include/mp_coefficient.hpp

@@ -0,0 +1,145 @@
+#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 RegularMLExpansionCF;
+  
+
+  template <typename RADIAL, typename entry_type=Complex>
+  class SphericalExpansionCF : public CoefficientFunction
+  {
+    SphericalExpansion<RADIAL, entry_type> mp;
+    Vec<3> center;
+  public:
+    SphericalExpansionCF (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, SphericalExpansion<TARGET, entry_type> & target) { mp.ShiftZ(z, target); }
+
+    using CoefficientFunction::Transform;        
+    template <typename TARGET>
+    void Transform (SphericalExpansionCF<TARGET, entry_type> & target)
+    {
+      mp.Transform (target.MP(), target.Center()-center);
+    }
+    template <typename TARGET>
+    void TransformAdd (SphericalExpansionCF<TARGET, entry_type> & target)
+    {
+      mp.TransformAdd (target.MP(), target.Center()-center);
+    }
+  };
+
+  template <typename entry_type>
+  class SingularMLExpansionCF : public CoefficientFunction
+  {
+    shared_ptr<SingularMLExpansion<entry_type>> mlmp;
+  public:
+    SingularMLExpansionCF (Vec<3> center, double r, double kappa)
+      : CoefficientFunction(sizeof(entry_type)/sizeof(Complex), true), mlmp{make_shared<SingularMLExpansion<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<SingularMLExpansion<entry_type>> MLExpansion() const { return mlmp; }
+    shared_ptr<RegularMLExpansionCF<entry_type>> CreateRegularExpansion(Vec<3> center, double r) const;
+  };
+  
+
+  template <typename entry_type>
+  class RegularMLExpansionCF : public CoefficientFunction
+  {
+    shared_ptr<RegularMLExpansion<entry_type>> mlmp;
+  public:
+    RegularMLExpansionCF (shared_ptr<SingularMLExpansionCF<entry_type>> asingmp, Vec<3> center, double r)
+      : CoefficientFunction(sizeof(entry_type)/sizeof(Complex), true), mlmp{make_shared<RegularMLExpansion<entry_type>>(asingmp->MLExpansion(), center, r, FMM_Parameters())} { } 
+    RegularMLExpansionCF (shared_ptr<SingularMLExpansion<entry_type>> asingmp, Vec<3> center, double r)
+      : CoefficientFunction(sizeof(entry_type)/sizeof(Complex), true), mlmp{make_shared<RegularMLExpansion<entry_type>>(asingmp, center, r, FMM_Parameters())} { } 
+    
+    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<RegularMLExpansion<entry_type>> MLExpansion() { return mlmp; }
+  };
+
+  
+}
+
+#endif