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

netgen/include/l2hofespace.hpp

@@ -0,0 +1,344 @@
+#ifndef FILE_L2HOFESPACE
+#define FILE_L2HOFESPACE
+
+/*********************************************************************/
+/* File:   l2hofespace.hpp                                           */
+/* Author: Start                                                     */
+/* Date:   23.Feb. 2003                                              */
+/*********************************************************************/
+
+#include "fespace.hpp"
+
+namespace ngcomp
+{
+  
+  /**
+     High Order Finite Element Space for L2 (element by element)
+  */
+
+  class NGS_DLL_HEADER L2HighOrderFESpace : public FESpace
+  {
+  protected:
+      
+    // if order is relative to mesh order 
+    bool var_order;
+    // variable order is set to mesh_order + rel_order 
+    int rel_order;
+    // order of elements 
+    Array<IVec<3> > order_inner;
+    // table of first element dofnumber 
+    Array<DofId> first_element_dof;
+    bool all_dofs_together;
+    // set all used dofs to hidden_dofs
+    bool hide_all_dofs;
+    COUPLING_TYPE lowest_order_ct;
+    bool tensorproduct;
+  public:
+
+    L2HighOrderFESpace (shared_ptr<MeshAccess> ama, const Flags & flags, bool parseflags=false);
+    ///
+    virtual ~L2HighOrderFESpace ();
+
+    static DocInfo GetDocu ();
+    
+    // Create if order=0 ElementFESpace Constructor, else L2HOFE 
+    static shared_ptr<FESpace> Create (shared_ptr<MeshAccess> ma, const Flags & flags);
+    // Creates also for order=0 a L2HighOrderFESpace 
+    static shared_ptr<FESpace> CreateHO (shared_ptr<MeshAccess> ma, const Flags & flags) 
+    {
+      return make_shared<L2HighOrderFESpace> (ma, flags);
+    }  
+  
+    virtual string GetClassName () const override
+    {
+      return "L2HighOrderFESpace";
+    }
+
+    bool AllDofsTogether(){return all_dofs_together;};
+    ///
+    void Update() override;
+    /// 
+    virtual void UpdateDofTables() override;
+    ///
+    virtual void UpdateCouplingDofArray() override;    
+    ///
+    // virtual size_t GetNDof () const throw() override;
+    ///
+    // virtual size_t GetNDofLevel (int level) const override;
+    ///
+    virtual FiniteElement & GetFE (ElementId ei, Allocator & alloc) const override;
+
+    using FESpace::GetFE;
+    // virtual const FiniteElement & GetFE (int elnr, LocalHeap & lh) const override;
+    // ///
+    // virtual const FiniteElement & GetSFE (int elnr, LocalHeap & lh) const override;
+    ///
+    virtual const FiniteElement & GetFacetFE (int fnr, LocalHeap & lh) const;
+
+    virtual void GetDofRanges (ElementId ei, Array<IntRange> & dranges) const;
+
+    virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
+
+    virtual void SetOrder (NodeId ni, int order) override;
+    virtual int GetOrder (NodeId ni) const override;
+    using FESpace::GetOrder;
+    
+    virtual FlatArray<VorB> GetDualShapeNodes (VorB vb) const override;
+
+    ///
+    virtual shared_ptr<Table<int>> CreateSmoothingBlocks (const Flags & precflags) const override;
+    /// 
+ 
+    virtual void GetVertexDofNrs (int vnr, Array<DofId> & dnums) const override;
+    virtual void GetEdgeDofNrs (int ednr, Array<DofId> & dnums) const override;
+    virtual void GetFaceDofNrs (int fanr, Array<DofId> & dnums) const override;
+    virtual void GetInnerDofNrs (int elnr, Array<DofId> & dnums) const override;
+
+
+    auto GetElementDofs (size_t nr) const
+    {
+      return Range (first_element_dof[nr], first_element_dof[nr+1]);
+    }
+
+    virtual shared_ptr<BaseMatrix> GetMassOperator (shared_ptr<CoefficientFunction> rho,
+                                                    shared_ptr<Region> defon,
+                                                    LocalHeap & lh) const override;
+
+    virtual shared_ptr<BaseMatrix> CreateMassOperator (shared_ptr<CoefficientFunction> rho,
+                                                       shared_ptr<Region> defon,
+                                                       bool inverse,
+                                                       LocalHeap & lh) const override;
+    
+    virtual void SolveM (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                         LocalHeap & lh) const override;
+    virtual void ApplyM (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                         LocalHeap & lh) const override;
+
+    virtual shared_ptr<BaseMatrix> GetTraceOperator (shared_ptr<FESpace> tracespace, bool avg) const override;
+    virtual void GetTrace (const FESpace & tracespace, const BaseVector & in, BaseVector & out, bool avg,
+                           LocalHeap & lh) const override;
+    virtual void GetTraceTrans (const FESpace & tracespace, const BaseVector & in, BaseVector & out, bool avg,
+                                LocalHeap & lh) const override;
+
+  protected:
+
+    template <ELEMENT_TYPE ET>
+      FiniteElement & T_GetFE (int elnr, Allocator & alloc) const;
+  };
+
+
+
+
+
+
+
+
+
+
+
+
+  class NGS_DLL_HEADER L2SurfaceHighOrderFESpace : public FESpace
+  {
+  protected:
+    // Level
+    // int level;
+
+    // Number of Elements
+    // int nel;
+
+    Array<int> first_element_dof;
+    // int ndof;
+
+
+    // if order is relative to mesh order 
+    bool var_order;
+    // variable order is set to mesh_order + rel_order 
+    int rel_order;
+    // order of elements 
+    Array<IVec<3> > order_inner;
+
+    bool lowest_order_wb;
+    bool discontinuous;
+    bool dual_mapping; // u(x) = 1/measure * u(hatx)
+  public:
+
+    L2SurfaceHighOrderFESpace (shared_ptr<MeshAccess> ama, const Flags & flags, bool parseflags=false);
+    ///
+    virtual ~L2SurfaceHighOrderFESpace ();
+
+    static DocInfo GetDocu ();
+
+    // static shared_ptr<FESpace> Create (shared_ptr<MeshAccess> ma, const Flags & flags);
+
+    virtual string GetClassName () const override
+    {
+      return "L2SurfaceHighOrderFESpace";
+    }
+
+    ///
+    void Update() override;
+    /// 
+    virtual void UpdateCouplingDofArray() override;    
+    //virtual void UpdateDofTables() override;
+    ///
+    // virtual size_t GetNDof () const throw() override;
+
+    virtual FiniteElement & GetFE (ElementId ei, Allocator & lh) const override;
+    ///
+    // virtual const FiniteElement & GetFE (int elnr, LocalHeap & lh) const override;
+    // ///
+    // virtual const FiniteElement & GetSFE (int elnr, LocalHeap & lh) const override;
+    ///
+    virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
+  
+    virtual FlatArray<VorB> GetDualShapeNodes (VorB vb) const override;
+
+    virtual shared_ptr<BaseMatrix> GetMassOperator (shared_ptr<CoefficientFunction> rho,
+                                                    shared_ptr<Region> defon,
+                                                    LocalHeap & lh) const override;
+    
+    virtual void SolveM (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                         LocalHeap & lh) const override;
+    virtual void ApplyM (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                         LocalHeap & lh) const override;
+    virtual shared_ptr<Table<int>> CreateSmoothingBlocks (const Flags & precflags) const override;
+    /// 
+    virtual void GetInnerDofNrs (int elnr, Array<DofId> & dnums) const override;
+    virtual void GetVertexDofNrs (int vnr, Array<DofId> & dnums) const override;
+    virtual void GetEdgeDofNrs (int ednr, Array<DofId> & dnums) const override;
+    virtual void GetFaceDofNrs (int fanr, Array<DofId> & dnums) const override;
+
+    virtual bool VarOrder() const override { return var_order; } 
+    virtual int GetRelOrder() const override { return rel_order; }
+
+    virtual void SetOrder (NodeId ni, int order) override;
+    virtual int GetOrder (NodeId ni) const override;
+    using FESpace::GetOrder;
+    
+    auto GetElementDofs (size_t nr) const
+    {
+      return Range (first_element_dof[nr], first_element_dof[nr+1]);
+    }
+
+  };
+
+
+  class NGS_DLL_HEADER VectorL2FESpace : public CompoundFESpace
+  {
+    bool piola = false;
+    bool piola2 = false;  // piola mapping with vertex oriended coordinates (new for prolongation)
+    bool covariant = false;
+  public:
+    VectorL2FESpace (shared_ptr<MeshAccess> ama, const Flags & flags, bool checkflags = false);
+
+    FiniteElement & GetFE (ElementId ei, Allocator & alloc) const override;
+
+    static DocInfo GetDocu ();
+    
+    void GetDofNrs (ElementId ei, Array<int> & dnums) const override;
+
+    virtual shared_ptr<BaseMatrix> GetMassOperator (shared_ptr<CoefficientFunction> rho,
+                                                    shared_ptr<Region> defon,
+                                                    LocalHeap & lh) const override;
+
+    virtual shared_ptr<BaseMatrix> CreateMassOperator (shared_ptr<CoefficientFunction> rho,
+                                                       shared_ptr<Region> defon,
+                                                       bool inverse,
+                                                       LocalHeap & lh) const override;
+
+    template <int DIM>
+    shared_ptr<BaseMatrix> CreateMassOperator_Dim (shared_ptr<CoefficientFunction> rho,
+                                                   shared_ptr<Region> defon,
+                                                   bool inverse,
+                                                   LocalHeap & lh) const;
+    
+    virtual void SolveM (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                         LocalHeap & lh) const override;
+    virtual void ApplyM (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                         LocalHeap & lh) const override;
+
+    virtual FlatArray<VorB> GetDualShapeNodes (VorB vb) const override;
+
+    template <int DIM>
+    void SolveM_Dim (CoefficientFunction * rho, BaseVector & vec, Region * region,
+                     LocalHeap & lh) const;
+
+    /*
+    template <int DIM>
+    void SolveMPiola (CoefficientFunction * rho, BaseVector & vec,
+                      LocalHeap & lh) const;
+    template <int DIM>
+    void SolveMCovariant (CoefficientFunction * rho, BaseVector & vec,
+                          LocalHeap & lh) const;
+    */
+    
+    template <int DIM>
+    void ApplyM_Dim (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                     LocalHeap & lh) const;
+
+    template <int DIM>
+    void ApplyMPiola (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                      LocalHeap & lh) const;
+    template <int DIM>
+    void ApplyMCovariant (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                          LocalHeap & lh) const;
+
+    virtual string GetClassName () const override
+    {
+      return "VectorL2FESpace";
+    }
+
+  };
+
+
+
+
+
+
+
+  class TangentialSurfaceL2FESpace : public CompoundFESpace
+  {
+    bool piola;
+  public:
+    TangentialSurfaceL2FESpace (shared_ptr<MeshAccess> ama, const Flags & flags, bool checkflags = false);
+
+    FiniteElement & GetFE (ElementId ei, Allocator & alloc) const override;
+
+    static DocInfo GetDocu ();
+    
+    void GetDofNrs (ElementId ei, Array<int> & dnums) const override;
+
+    virtual FlatArray<VorB> GetDualShapeNodes (VorB vb) const override;
+
+    virtual shared_ptr<BaseMatrix> GetMassOperator (shared_ptr<CoefficientFunction> rho,
+                                                    shared_ptr<Region> defon,
+                                                    LocalHeap & lh) const override;
+    
+    virtual void SolveM (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                         LocalHeap & lh) const override;
+    virtual void ApplyM (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                         LocalHeap & lh) const override;
+
+
+    template <int DIM>
+    void SolveM_Dim (CoefficientFunction * rho, BaseVector & vec, Region * region,
+                     LocalHeap & lh) const;
+
+    template <int DIM>
+    void ApplyM_Dim (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                     LocalHeap & lh) const;
+
+    virtual string GetClassName () const override
+    {
+      return "TangentialSurfaceL2FESpace";
+    }
+
+  };
+
+
+
+  
+}
+
+#endif
+

netgen/include/la.hpp

@@ -0,0 +1,38 @@
+#ifndef FILE_NGLA
+#define FILE_NGLA
+
+#include <bla.hpp>
+
+/** namespace for linear algebra.
+ */
+
+namespace ngla
+{
+  using namespace std;
+  using namespace ngstd;
+  using namespace ngbla;
+}
+
+
+#include "paralleldofs.hpp"
+#include "basevector.hpp"
+#include "vvector.hpp"
+#include "multivector.hpp"
+#include "basematrix.hpp"
+#include "sparsematrix.hpp"
+#include "sparsematrix_dyn.hpp"
+#include "order.hpp"
+#include "sparsecholesky.hpp"
+#include "pardisoinverse.hpp"
+#include "jacobi.hpp"
+#include "blockjacobi.hpp"
+#include "commutingAMG.hpp"
+#include "diagonalmatrix.hpp"
+#include "special_matrix.hpp"
+#include "elementbyelement.hpp"
+#include "cg.hpp"
+#include "chebyshev.hpp"
+#include "eigen.hpp"
+#include "arnoldi.hpp"
+
+#endif

netgen/include/linearform.hpp

@@ -0,0 +1,266 @@
+#ifndef FILE_LINEARFORM
+#define FILE_LINEARFORM
+
+/*********************************************************************/
+/* File:   linearform.hh                                             */
+/* Author: Joachim Schoeberl                                         */
+/* Date:   25. Mar. 2000                                             */
+/*********************************************************************/
+
+
+#include "fespace.hpp"
+
+namespace ngcomp
+{
+
+  /** 
+      Linearform
+  */
+
+  
+  class NGS_DLL_HEADER LinearForm : public NGS_Object
+  {
+  protected:
+    ///
+    shared_ptr<FESpace> fespace;
+    ///
+    Array<shared_ptr<LinearFormIntegrator>> parts;
+    Array<shared_ptr<LinearFormIntegrator>> VB_parts[4];
+    Array<shared_ptr<class PointEvaluationFunctional>> pnteval;
+    /// do the integration on independent meshes
+    bool independent;
+    /// print the assembled vector to testout
+    bool print;
+    /// print element vectos to testout
+    bool printelvec;
+
+    bool allocated;
+    bool assembled;
+    bool initialassembling;
+
+    int cacheblocksize;
+    /// output of norm of matrix entries
+    bool checksum;
+
+  public:
+    ///
+    LinearForm (shared_ptr<FESpace> afespace, 
+		const string & aname, const Flags & flags);
+
+    ///
+    virtual ~LinearForm () { ; }
+  
+    ///
+    shared_ptr<FESpace> GetFESpace() const { return fespace; }
+
+    ///
+    virtual LinearForm & AddIntegrator (shared_ptr<LinearFormIntegrator> lfi);
+
+    LinearForm & operator+= (shared_ptr<LinearFormIntegrator> lfi)
+    {
+      return AddIntegrator(lfi);
+    }
+
+    ///
+    shared_ptr<LinearFormIntegrator> GetIntegrator (int i) const
+    {
+      return parts[i]; 
+    }
+
+    const Array<shared_ptr<LinearFormIntegrator>> & Integrators() const
+    {
+      return parts;
+    }
+
+    ///
+    int NumIntegrators () const
+    {
+      return parts.Size(); 
+    }
+
+    LinearForm & operator+= (shared_ptr<PointEvaluationFunctional> _pnteval)
+      {
+        pnteval += _pnteval;
+        return *this;
+      }
+    
+    void SetIndependent (bool aindependent = true)
+    { 
+      independent = aindependent; 
+    }
+
+    ///
+    virtual void Assemble (LocalHeap & lh) = 0;
+    ///
+    virtual void AllocateVector () = 0;
+
+    virtual void CleanUpLevel() { ; }
+
+    virtual bool IsAssembled () { return assembled; }
+    bool InitialAssembling () { return initialassembling; }
+    void SetNoInitialAssembling () { initialassembling = false; }
+
+
+    ///
+    virtual shared_ptr<BaseVector> GetVectorPtr() const = 0;
+    virtual BaseVector & GetVector () const = 0;
+
+    ///
+    virtual string GetClassName () const
+    {
+      return "LinearForm";
+    }
+
+    void SetPrint (bool ap);
+    void SetPrintElmat (bool ap);
+
+    ///
+    virtual void PrintReport (ostream & ost) const;
+    ///
+    virtual Array<MemoryUsage> GetMemoryUsage () const;
+      
+    virtual void AddElementVector (FlatArray<int> dnums,
+                                   FlatVector<double> elvec,
+				   int cachecomp = -1);
+    virtual void SetElementVector (FlatArray<int> dnums,
+				   FlatVector<double> elvec);
+    virtual void GetElementVector (FlatArray<int> dnums,
+				   FlatVector<double> elvec) const;
+
+    virtual void AddElementVector (FlatArray<int> dnums,
+				   FlatVector<Complex> elvec,
+				   int cachecomp = -1);
+    virtual void SetElementVector (FlatArray<int> dnums,
+                                   FlatVector<Complex> elvec);
+    virtual void GetElementVector (FlatArray<int> dnums,
+				   FlatVector<Complex> elvec) const;
+
+
+
+    virtual void SetCacheBlockSize (const int size)
+    {
+      cacheblocksize = size;
+    }
+  };
+
+
+  template <class SCAL>
+  class NGS_DLL_HEADER S_LinearForm : public LinearForm
+  {
+  protected:
+    shared_ptr<BaseVector> vec;    
+    
+  public:
+    typedef SCAL TSCAL;
+    using LinearForm::LinearForm;
+
+    virtual BaseVector & GetVector () const override { return *vec; }
+    virtual shared_ptr<BaseVector> GetVectorPtr () const override { return vec; }
+
+    virtual void AllocateVector () override;
+    virtual void CleanUpLevel() override;    
+    ///
+    virtual void AddElementVector (FlatArray<int> dnums,
+                                   FlatVector<SCAL> elvec,
+                                   int cachecomp = -1) override = 0;
+    virtual void SetElementVector (FlatArray<int> dnums,
+                                   FlatVector<SCAL> elvec) override;
+    virtual void GetElementVector (FlatArray<int> dnums,
+				   FlatVector<SCAL> elvec) const override;
+
+    ///
+    virtual void Assemble (LocalHeap & lh) override;
+    void AssembleIndependent (LocalHeap & lh);
+  };
+
+
+
+
+
+
+  /// Template argument specifies vector type
+  template <class TV>
+  class NGS_DLL_HEADER T_LinearForm : public S_LinearForm<typename mat_traits<TV>::TSCAL>
+  {
+    ///
+    // shared_ptr<VVector<TV>> vec;
+    typedef S_LinearForm<typename mat_traits<TV>::TSCAL> BASE;
+    using BASE::vec;
+  public:
+
+    typedef typename mat_traits<TV>::TSCAL TSCAL;
+    // enum { HEIGHT = mat_traits<TV>::HEIGHT };
+
+    ///
+    using S_LinearForm<TSCAL>::S_LinearForm;
+
+    ///
+    virtual ~T_LinearForm () { };
+
+    ///
+    // virtual void AllocateVector () override;
+    ///
+    // virtual void CleanUpLevel() override;
+
+    ///
+    virtual void AddElementVector (FlatArray<int> dnums,
+				   FlatVector<TSCAL> elvec,
+                                   int cachecomp = -1) override;
+    /*
+    virtual void SetElementVector (FlatArray<int> dnums,
+                                   FlatVector<TSCAL> elvec) override;
+    virtual void GetElementVector (FlatArray<int> dnums,
+				   FlatVector<TSCAL> elvec) const override;
+    */
+  };
+
+
+
+
+
+  class ComponentLinearForm : public LinearForm
+  {
+    shared_ptr<LinearForm> base_lf;
+    int comp;
+  public:
+    ComponentLinearForm (shared_ptr<LinearForm> abase_lf, int acomp, int ancomp);
+    virtual LinearForm & AddIntegrator (shared_ptr<LinearFormIntegrator> lfi);
+
+    virtual void AllocateVector () { cerr << "comp - allocate is illegal" << endl; }
+    virtual void Assemble (LocalHeap & lh) { cerr << "comp - assemble is illegal" << endl; }
+    virtual shared_ptr<BaseVector> GetVectorPtr() const
+    {
+      auto fes = dynamic_pointer_cast<CompoundFESpace> (base_lf->GetFESpace());
+      return base_lf->GetVectorPtr()->Range(fes->GetRange(comp));
+      // throw Exception ("comp - GetVectorPtr is illegal");
+    }
+    virtual BaseVector & GetVector () const 
+    { throw Exception ("comp - GetVector is illegal"); }
+  };
+
+
+
+  extern NGS_DLL_HEADER shared_ptr<LinearForm> CreateLinearForm (shared_ptr<FESpace> space,
+                                                                 const string & name,
+                                                                 const Flags & flags);
+
+
+  class PointEvaluationFunctional
+  {
+  public:
+    shared_ptr<CoefficientFunction> cf;
+    Vector<> point;
+  public:
+    PointEvaluationFunctional (shared_ptr<CoefficientFunction> acf,
+                               Vector<> apoint)
+      : cf(acf), point(apoint) { }
+    
+    SparseVector<double> Assemble() const;
+  };
+  
+
+}
+
+#endif
+
+