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

ngsolve-6.2.2506.post216.dev0.data/data/include/netgen/gridfunction.hpp

@@ -0,0 +1,525 @@
+#ifndef FILE_GRIDFUNCTION
+#define FILE_GRIDFUNCTION
+
+/*********************************************************************/
+/* File:   gridfunction.hpp                                           */
+/* Author: Joachim Schoeberl                                         */
+/* Date:   10. Jul. 2000                                             */
+/*********************************************************************/
+
+
+#include <meshing/soldata.hpp>   // netgen visualization
+#include "fespace.hpp"
+
+namespace ngcomp
+{
+
+
+  class GridFunction;
+
+  class NGS_DLL_HEADER GridFunctionCoefficientFunction : public CoefficientFunctionNoDerivative
+  {
+  protected:
+    shared_ptr<GridFunction> gf_shared_ptr;
+    GridFunction* gf;
+    shared_ptr<FESpace> fes;
+    shared_ptr<DifferentialOperator> diffop[4];
+    int comp;
+    GridFunctionCoefficientFunction (shared_ptr<DifferentialOperator> adiffop,
+                                     shared_ptr<DifferentialOperator> atrace_diffop = nullptr,
+				     shared_ptr<DifferentialOperator> attrace_diffop = nullptr,
+				     shared_ptr<DifferentialOperator> atttrace_diffop = nullptr,                                     
+                                     int acomp = 0);
+  public:
+    GridFunctionCoefficientFunction () = default;
+    GridFunctionCoefficientFunction (shared_ptr<GridFunction> agf, int acomp = 0);
+    GridFunctionCoefficientFunction (shared_ptr<GridFunction> agf, 
+                                     shared_ptr<DifferentialOperator> adiffop,
+                                     shared_ptr<DifferentialOperator> atrace_diffop = nullptr,
+				     shared_ptr<DifferentialOperator> attrace_diffop = nullptr,
+				     shared_ptr<DifferentialOperator> atttrace_diffop = nullptr,
+                                     int acomp = 0);
+    GridFunctionCoefficientFunction (shared_ptr<GridFunction> agf, 
+                                     shared_ptr<BilinearFormIntegrator> abfi, int acomp = 0);
+    GridFunctionCoefficientFunction (shared_ptr<GridFunction> agf, shared_ptr<ProxyFunction> proxy);
+    
+    virtual ~GridFunctionCoefficientFunction ();
+    void DoArchive(Archive& ar) override;
+    /// scalar valued or vector valued
+    virtual bool IsComplex() const;
+    virtual int Dimension() const;
+    virtual Array<int> Dimensions() const;
+    virtual bool DefinedOn (const ElementTransformation & trafo) override;
+    void SelectComponent (int acomp) { comp = acomp; }
+    const GridFunction & GetGridFunction() const { return *gf; }
+      using CoefficientFunction::Evaluate;
+      using CoefficientFunctionNoDerivative::Evaluate;
+    virtual double Evaluate (const BaseMappedIntegrationPoint & ip) const override;
+    virtual Complex EvaluateComplex (const BaseMappedIntegrationPoint & ip) const override; 
+
+    virtual void Evaluate(const BaseMappedIntegrationPoint & ip,
+			  FlatVector<> result) const override;
+    virtual void Evaluate(const BaseMappedIntegrationPoint & ip,
+			  FlatVector<Complex> result) const override;
+    
+    virtual void Evaluate (const BaseMappedIntegrationRule & ir, 
+			   BareSliceMatrix<double> values) const override;
+    virtual void Evaluate (const BaseMappedIntegrationRule & ir, 
+			   BareSliceMatrix<Complex> values) const override;
+    virtual void Evaluate (const SIMD_BaseMappedIntegrationRule & ir, BareSliceMatrix<SIMD<double>> values) const override;
+    virtual void Evaluate (const SIMD_BaseMappedIntegrationRule & ir, BareSliceMatrix<SIMD<Complex>> values) const override;
+
+    virtual bool StoreUserData() const override { return true; }
+
+    virtual void NonZeroPattern (const class ProxyUserData & ud, FlatVector<AutoDiffDiff<1,NonZero>> nonzero) const override
+    {
+      nonzero = AutoDiffDiff<1,NonZero> (true);
+    }
+
+    // generation information for pickling:
+    bool generated_from_deriv = false;
+    string generated_from_operator;
+    shared_ptr<GridFunction> GetGridFunctionPtr() const { return gf_shared_ptr; }
+    const auto & GetDifferentialOperator (VorB vb) const { return diffop[vb]; }
+
+    virtual shared_ptr<CoefficientFunction>
+      Diff (const CoefficientFunction * var, shared_ptr<CoefficientFunction> dir) const override;
+
+    shared_ptr<CoefficientFunction> Primary() const override;
+    shared_ptr<GridFunctionCoefficientFunction> GetTrace() const;
+  };
+
+
+
+
+ 
+
+  /** 
+      Grid-functions
+  */
+  class NGS_DLL_HEADER GridFunction 
+    : public GridFunctionCoefficientFunction // , public NGS_Object
+  {
+  protected:
+    string name;
+    Flags flags;
+    Flags flaglist;
+    /// the finite element space
+    shared_ptr<FESpace> fespace;
+    /// should we do a prolongation from one multigrid-level to the next ?
+    bool nested;
+    /// should the GF be updated automatically on an update of the underliying space?
+    bool autoupdate;
+    /// should we visualize the gridfunction ?
+    bool visual;
+    /// how many functions
+    int multidim;
+    /// highest multigrid-level for which Update was called (memory allocation)
+    int level_updated = -1;
+
+    /// used for many right-hand-sides
+    int cacheblocksize = 1;
+    /// Component gridfunctions living somewhere - need to call update on them
+    Array<weak_ptr<GridFunction>> compgfs;
+    /// the actual data, array for multi-dim 
+    Array<shared_ptr<BaseVector>> vec;
+    /// component GridFunctions if fespace is a CompoundFESpace
+    weak_ptr<GridFunctionCoefficientFunction> derivcf;
+  public:
+    /// 
+    explicit GridFunction () = default;
+    GridFunction (shared_ptr<FESpace> afespace, 
+		  const string & name = "gfu", 
+		  const Flags & flags = Flags());
+    ///
+    virtual ~GridFunction ();
+    ///
+    virtual void Update ();
+    ///
+    bool DoesAutoUpdate () const { return autoupdate; }
+    void ConnectAutoUpdate();
+    
+    ///
+    virtual void DoArchive (Archive & archive) override;
+    ///  
+    virtual BaseVector & GetVector (int comp = 0) { return *vec[comp]; }
+    virtual const BaseVector & GetVector (int comp = 0) const  { return *vec[comp]; }
+    ///  
+    virtual shared_ptr<BaseVector> GetVectorPtr (int comp = 0) const  { return vec[comp]; }
+    auto GetVectors() const { return MultiVector(vec); }
+    ///
+    void SetNested (int anested = 1) { nested = anested; }
+    ///
+    bool GetVisual () const { return visual; }
+    ///
+    void SetVisual (bool avisual = 1) { visual = avisual; }
+
+    int GetMultiDim () const { return multidim; }
+
+    /// increase multidim and copy vec to new component
+    void AddMultiDimComponent (BaseVector & vec, bool copy = true);
+  
+    int GetLevelUpdated() const { return level_updated; }
+    ///
+
+    // const FESpace & GetFESpace() const { return *fespace; }
+    ///
+    const shared_ptr<FESpace> & GetFESpace() const { return fespace; }
+    ///
+    const shared_ptr<MeshAccess> & GetMeshAccess() const { return fespace->GetMeshAccess(); }
+    ///
+    virtual string GetClassName () const
+    {
+      return "GridFunction";
+    }
+
+    void SetName(const string & aname) { name = aname; }
+    string GetName () const { return name; }
+
+    const Flags& GetFlags() const { return flags; }
+    Flags& GetFlags() { return flags; }
+
+    virtual void Interpolate (const CoefficientFunction & cf,
+                              const Region * reg, int mdcomp, LocalHeap & lh);
+
+    ///
+    virtual void PrintReport (ostream & ost) const override;
+    ///
+    virtual Array<MemoryUsage> GetMemoryUsage () const;
+
+    // void Visualize(const string & name);
+
+    ///
+    virtual void SetCacheBlockSize (const int size) {cacheblocksize = size;}
+    ///
+    virtual int GetCacheBlockSize (void) const { return cacheblocksize;}
+    ///
+    virtual bool IsUpdated () const; 
+
+    
+    int GetNComponents () const
+    {
+      auto compfes = dynamic_pointer_cast<CompoundFESpace>(fespace);
+      if(compfes)
+        return compfes->GetNSpaces();
+      return 0;
+    }
+    shared_ptr<GridFunction> GetComponent (int compound_comp);
+
+    [[deprecated("Use GridFunction.Deriv instead!")]]
+    shared_ptr<GridFunctionCoefficientFunction> GetDeriv()
+    {
+      return Deriv();
+    }
+
+    shared_ptr<GridFunctionCoefficientFunction> Deriv()
+    {
+      auto res = derivcf.lock();
+      if(res) return res;
+
+      // derivcf is not set -> initialize it
+      res =
+        make_shared<GridFunctionCoefficientFunction> (dynamic_pointer_cast<GridFunction> (shared_from_this()),
+                                                      GetFESpace()->GetFluxEvaluator(),
+                                                      GetFESpace()->GetFluxEvaluator(BND),
+                                                      GetFESpace()->GetFluxEvaluator(BBND));
+      res -> generated_from_deriv = true;
+      derivcf = res;
+      return res;
+    }
+
+    shared_ptr<CoefficientFunction> Operator (shared_ptr<DifferentialOperator> diffop) const override;
+    shared_ptr<CoefficientFunction> Operator (const string& name) const override;
+    
+    
+    ///
+    virtual void GetElementVector (FlatArray<int> dnums,
+				   FlatVector<double> elvec) const
+    { vec[0] -> GetIndirect (dnums, elvec); }
+      
+    ///
+    virtual void SetElementVector (FlatArray<int> dnums,
+				   FlatVector<double> elvec) 
+    { vec[0] -> SetIndirect (dnums, elvec); }
+
+
+    ///
+    virtual void GetElementVector (int comp,
+				   FlatArray<int> dnums,
+				   FlatVector<double> elvec) const 
+    { vec[comp] -> GetIndirect (dnums, elvec); }
+
+
+    ///
+    virtual void SetElementVector (int comp,
+				   FlatArray<int> dnums,
+				   FlatVector<double> elvec) 
+    { vec[comp] -> SetIndirect (dnums, elvec); }
+
+    ///
+    virtual void GetElementVector (FlatArray<int> dnums,
+				   FlatVector<Complex> elvec) const
+    { vec[0] -> GetIndirect (dnums, elvec); }
+      
+    ///
+    virtual void SetElementVector (FlatArray<int> dnums,
+				   FlatVector<Complex> elvec) 
+    { vec[0] -> SetIndirect (dnums, elvec); }
+
+
+    ///
+    virtual void GetElementVector (int comp,
+				   FlatArray<int> dnums,
+				   FlatVector<Complex> elvec) const 
+    { vec[comp] -> GetIndirect (dnums, elvec); }
+
+
+    ///
+    virtual void SetElementVector (int comp,
+				   FlatArray<int> dnums,
+				   FlatVector<Complex> elvec) 
+    { vec[comp] -> SetIndirect (dnums, elvec); }
+
+
+    // multidim component, if -1 then all components are loaded/saved
+    virtual void Load (istream & ist, int mdcomp = -1) = 0;
+    virtual void Save (ostream & ost, int mdcomp = -1) const = 0;
+  };
+
+
+  inline ostream & operator<< (ostream & ost, const GridFunction & gf)
+  {
+    gf.PrintReport (ost);
+    return ost;
+  }
+
+  
+  extern NGS_DLL_HEADER void Visualize(shared_ptr<GridFunction> gf, const string & name);
+  
+  template <class SCAL>
+  class NGS_DLL_HEADER S_GridFunction : public GridFunction
+  {
+  public:
+    S_GridFunction () = default;
+    S_GridFunction (shared_ptr<FESpace> afespace, 
+		    const string & aname = "gfu", 
+		    const Flags & flags = Flags());
+      
+    // parallel Load/Save by Martin Huber and Lothar Nannen 
+    virtual void Load (istream & ist, int mdcomp);
+    virtual void Save (ostream & ost, int mdcomp) const;
+
+    virtual void Update ();
+
+  private:
+    template <int N, NODE_TYPE NT> void LoadNodeType (istream & ist, int mdcomp);
+    template <int N, NODE_TYPE NT> void SaveNodeType (ostream & ost, int mdcomp) const;
+  };
+
+
+
+  template <class TV>
+  class NGS_DLL_HEADER T_GridFunction : public S_GridFunction<typename mat_traits<TV>::TSCAL>
+  {
+  public:
+    typedef typename mat_traits<TV>::TSCAL TSCAL;
+
+    [[deprecated("Use T_GridFunction(shared_ptr<FESpace> ... instead!")]] 
+    T_GridFunction (const FESpace & afespace, 
+		    const string & aname = "gfu", 
+		    const Flags & flags = Flags())
+      : T_GridFunction(shared_ptr<FESpace> (const_cast<FESpace*>(&afespace),NOOP_Deleter), aname, flags)
+      { ; } 
+
+    T_GridFunction (shared_ptr<FESpace> afespace, 
+		    const string & aname = "gfu", 
+		    const Flags & flags = Flags())
+      : S_GridFunction<TSCAL> (afespace, aname, flags)
+      { ; }
+
+    virtual ~T_GridFunction () { ; } 
+  };
+
+
+
+
+  extern NGS_DLL_HEADER 
+  shared_ptr<GridFunction> CreateGridFunction (shared_ptr<FESpace> space,
+                                               const string & name, const Flags & flags);
+
+  [[deprecated("Use CreateGridFunction(shared_ptr<FESpace> ... instead!")]]   
+  inline 
+  shared_ptr<GridFunction> CreateGridFunction (const FESpace * space,
+                                               const string & name, const Flags & flags)
+  {
+    return 
+      CreateGridFunction (shared_ptr<FESpace> (const_cast<FESpace*>(space), NOOP_Deleter), 
+                          name, flags);
+  }
+
+
+
+  class NGS_DLL_HEADER ComponentGridFunction : public GridFunction
+  {
+    shared_ptr<GridFunction> gf_parent;
+    int comp;
+  public:
+    ComponentGridFunction (shared_ptr<GridFunction> agf_parent, int acomp);
+    ~ComponentGridFunction () override;
+    void Update () override;
+    void Load(istream& ist, int mdcomp) override { throw Exception("Load not implemented for ComponentGF"); }
+    void Save(ostream& ost, int mdcomp) const override { throw Exception("Save not implemented for ComponentGF"); }
+    shared_ptr<GridFunction> GetParent() const { return gf_parent; }
+    int GetComponent() const { return comp; }
+  };
+  
+
+
+
+
+  
+  template <class SCAL>
+  class NGS_DLL_HEADER VisualizeGridFunction : public netgen::SolutionData
+  {
+    shared_ptr<MeshAccess> ma;
+    shared_ptr<GridFunction> gf;
+    Array<shared_ptr<BilinearFormIntegrator>> bfi2d;
+    Array<shared_ptr<BilinearFormIntegrator>> bfi3d;
+    bool applyd;
+
+  public:
+    VisualizeGridFunction (shared_ptr<MeshAccess> ama,
+			   shared_ptr<GridFunction> agf,
+			   const shared_ptr<BilinearFormIntegrator> abfi2d,
+			   const shared_ptr<BilinearFormIntegrator> abfi3d,
+			   bool aapplyd);
+    VisualizeGridFunction (shared_ptr<MeshAccess> ama,
+			   shared_ptr<GridFunction> agf,
+			   const Array<shared_ptr<BilinearFormIntegrator>> & abfi2d,
+			   const Array<shared_ptr<BilinearFormIntegrator>> & abfi3d,
+			   bool aapplyd);
+
+    virtual ~VisualizeGridFunction ();
+  
+    virtual bool GetValue (int elnr, 
+			   double lam1, double lam2, double lam3,
+			   double * values) ;
+
+    virtual bool GetValue (int elnr, 
+			   const double xref[], const double x[], const double dxdxref[],
+			   double * values) ;
+
+    virtual bool GetMultiValue (int elnr, int facetnr, int npts,
+				const double * xref, int sxref,
+				const double * x, int sx,
+				const double * dxdxref, int sdxdxref,
+				double * values, int svalues);
+
+    virtual bool GetSurfValue (int elnr, int facetnr,
+			       double lam1, double lam2, 
+			       double * values) ;
+
+    virtual bool GetSurfValue (int selnr, int facetnr, 
+			       const double xref[], const double x[], const double dxdxref[],
+			       double * values);
+
+    virtual bool GetMultiSurfValue (int selnr, int facetnr, int npts,
+                                    const double * xref, int sxref,
+                                    const double * x, int sx,
+                                    const double * dxdxref, int sdxdxref,
+                                    double * values, int svalues);
+
+    virtual bool GetMultiSurfValue (size_t selnr, size_t facetnr, size_t npts,
+                                    const SIMD<double> * xref,
+                                    const SIMD<double> * x,
+                                    const SIMD<double> * dxdxref,
+                                    SIMD<double> * values);
+
+    virtual bool GetSegmentValue (int segnr, double xref, double * values);
+
+    virtual int GetNumMultiDimComponents ()
+    {
+      return gf->GetMultiDim();
+    }
+
+
+    void Analyze(Array<double> & minima, Array<double> & maxima, Array<double> & averages, int component = -1);
+    void Analyze(Array<double> & minima, Array<double> & maxima, Array<double> & averages_times_volumes, Array<double> & volumes, int component = -1);
+    
+
+  };
+
+
+
+
+
+
+
+
+
+
+
+
+
+  class NGS_DLL_HEADER VisualizeCoefficientFunction : public netgen::SolutionData
+  {
+    shared_ptr<MeshAccess> ma;
+    shared_ptr<CoefficientFunction> cf;
+    // LocalHeap lh;
+  public:
+    VisualizeCoefficientFunction (shared_ptr<MeshAccess> ama,
+				  shared_ptr<CoefficientFunction> acf);
+    
+    virtual ~VisualizeCoefficientFunction ();
+  
+    virtual bool GetValue (int elnr, 
+			   double lam1, double lam2, double lam3,
+			   double * values) ;
+
+    virtual bool GetValue (int elnr, 
+			   const double xref[], const double x[], const double dxdxref[],
+			   double * values) ;
+
+    virtual bool GetMultiValue (int elnr, int facetnr, int npts,
+				const double * xref, int sxref,
+				const double * x, int sx,
+				const double * dxdxref, int sdxdxref,
+				double * values, int svalues);
+
+    virtual bool GetSurfValue (int elnr, int facetnr,
+			       double lam1, double lam2, 
+			       double * values) ;
+
+    virtual bool GetSurfValue (int selnr, int facetnr, 
+			       const double xref[], const double x[], const double dxdxref[],
+			       double * values);
+
+    virtual bool GetMultiSurfValue (int selnr, int facetnr, int npts,
+                                    const double * xref, int sxref,
+                                    const double * x, int sx,
+                                    const double * dxdxref, int sdxdxref,
+                                    double * values, int svalues);
+
+    virtual bool GetMultiSurfValue (size_t selnr, size_t facetnr, size_t npts,
+                                    const SIMD<double> * xref,
+                                    const SIMD<double> * x,
+                                    const SIMD<double> * dxdxref,
+                                    SIMD<double> * values);
+
+    virtual bool GetSegmentValue (int segnr, double xref, double * values);
+
+    void Analyze(Array<double> & minima, Array<double> & maxima, Array<double> & averages, int component = -1);
+    void Analyze(Array<double> & minima, Array<double> & maxima, Array<double> & averages_times_volumes, Array<double> & volumes, int component = -1);
+
+
+    virtual int GetNumMultiDimComponents ();
+    virtual void SetMultiDimComponent (int mc);
+  };
+
+
+
+}
+
+
+
+#endif

ngsolve-6.2.2506.post216.dev0.data/data/include/netgen/h1amg.hpp

@@ -0,0 +1,124 @@
+#ifndef H1AMGxx_HPP_
+#define H1AMGxx_HPP_
+
+// #include <la.hpp>
+#include <basematrix.hpp>
+#include <sparsematrix.hpp>
+#include <preconditioner.hpp>
+
+namespace ngcomp
+{
+  using namespace ngla;
+
+
+
+  struct H1AMG_Parameters
+  {
+    int verbose = 0;
+    int smoothing_steps = 3;
+    int coarsenings_per_level = 3; // number of binary coarsenings per level
+    bool block_smoother = true;    // block or point smoother ?
+    bool use_smoothed_prolongation = true;
+    int max_coarse = 10;
+    int max_level = 20;
+  };
+
+  
+  template <class SCAL>
+  class NGS_DLL_HEADER H1AMG_Matrix : public ngla::BaseMatrix
+  {
+    size_t size;
+    std::shared_ptr<ngla::SparseMatrixTM<SCAL>> mat;
+    std::shared_ptr<ngla::BaseBlockJacobiPrecond> smoother;
+    std::shared_ptr<ngla::SparseMatrixTM<double>> prolongation, restriction;
+    std::shared_ptr<ngla::BaseMatrix> coarse_precond;
+    int smoothing_steps = 1;
+
+  public:
+    H1AMG_Matrix (std::shared_ptr<ngla::SparseMatrixTM<SCAL>> amat,
+                  std::shared_ptr<ngcore::BitArray> freedofs,
+                  ngcore::FlatArray<ngcore::IVec<2>> e2v,
+                  ngcore::FlatArray<double> edge_weights,
+                  ngcore::FlatArray<double> vertex_weights,
+                  const H1AMG_Parameters & param,                  
+                  size_t level);
+
+    virtual int VHeight() const override { return size; }
+    virtual int VWidth() const override { return size; }
+    virtual bool IsComplex() const override { return is_same<SCAL,Complex>(); }
+    
+    virtual AutoVector CreateRowVector () const override { return mat->CreateColVector(); }
+    virtual AutoVector CreateColVector () const override { return mat->CreateRowVector(); }
+
+    virtual void Mult (const ngla::BaseVector & b, ngla::BaseVector & x) const override;
+  };
+
+
+
+
+
+  template <class SCAL>
+  class H1AMG_Preconditioner : public Preconditioner
+  {
+    shared_ptr<BitArray> freedofs;
+    shared_ptr<H1AMG_Matrix<SCAL>> mat;
+
+    ParallelHashTable<IVec<2>,double> edge_weights_ht;
+    ParallelHashTable<IVec<1>,double> vertex_weights_ht;
+    
+    H1AMG_Parameters param;
+    
+  public:
+
+    static shared_ptr<Preconditioner> CreateBF (shared_ptr<BilinearForm> bfa, const Flags & flags, const string & name)
+    {
+      if (bfa->GetFESpace()->IsComplex())
+        return make_shared<H1AMG_Preconditioner<Complex>> (bfa, flags, name);
+      else
+        return make_shared<H1AMG_Preconditioner<double>> (bfa, flags, name);
+    }
+
+    static DocInfo GetDocu ();    
+
+    H1AMG_Preconditioner (shared_ptr<BilinearForm> abfa, const Flags & aflags,
+                          const string aname = "H1AMG_cprecond")
+      : Preconditioner (abfa, aflags, aname)
+    {
+      if (is_same<SCAL,double>::value)
+        cout << IM(3) << "Create H1AMG" << endl;
+      else
+        cout << IM(3) << "Create H1AMG, complex" << endl;
+      
+      param.verbose = int(flags.GetNumFlag("verbose", 0));
+      param.smoothing_steps = int(flags.GetNumFlag("smoothingsteps", 1));    
+      param.use_smoothed_prolongation = flags.GetDefineFlagX("smoothedprolongation").IsMaybeTrue();
+      param.max_coarse = int(flags.GetNumFlag("maxcoarse", 10));
+      param.max_level = int(flags.GetNumFlag("maxlevel", 20));
+    }
+
+    virtual void InitLevel (shared_ptr<BitArray> _freedofs) override
+    {
+      freedofs = _freedofs;
+    }
+
+    virtual void FinalizeLevel (const BaseMatrix * matrix) override;
+
+    virtual void AddElementMatrix (FlatArray<int> dnums,
+                                   FlatMatrix<SCAL> elmat,
+                                   ElementId id,
+                                   LocalHeap & lh) override;
+
+    virtual void Update () override { ; }
+
+    virtual const BaseMatrix & GetMatrix() const override 
+    {
+      return *mat;
+    }
+
+  };
+
+
+  
+}
+
+#endif // H1AMG_HPP_