ngsolve 6.2.2406__cp311-cp311-macosx_10_15_universal2.whl → 6.2.2406.post111.dev1__cp311-cp311-macosx_10_15_universal2.whl

netgen/include/arnoldi.hpp

@@ -8,6 +8,9 @@
 /* Date:   5. Jul. 96                                                     */
 /**************************************************************************/
 
+
+#include "basematrix.hpp"
+
 namespace ngla
 {
   /**

netgen/include/basematrix.hpp

@@ -8,10 +8,15 @@
 /* Date:   25. Mar. 2000                                             */
 /*********************************************************************/
 
-namespace ngla
-{
 
+#include "basevector.hpp"
+#include "multivector.hpp"
+// #include "paralleldofs.hpp"
 
+namespace ngla
+{
+  class ParallelDofs;
+  
   // sets the solver which is used for InverseMatrix
   enum INVERSETYPE { PARDISO, PARDISOSPD, SPARSECHOLESKY, SUPERLU, SUPERLU_DIST, MUMPS, MASTERINVERSE, UMFPACK };
   extern string GetInverseName (INVERSETYPE type);
@@ -268,14 +273,6 @@ namespace ngla
     void AssignTo (TS s, BaseVector & v) const
     { 
       CheckSize (v);
-      /*
-      if (m.Height() != v.Size() || m.Width() != x.Size())
-	throw Exception (ToString ("matrix-vector: size does not fit\n") +
-                         "matrix-type = " + typeid(m).name() +
-			 "Matrix:     " + ToString(m.Height()) + " x " + ToString(m.Width()) + "\n"
-			 "Vector in : " + ToString(x.Size()) + "\n"
-			 "Vector res: " + ToString(v.Size()));
-      */
       m.Mult (x, v);
       v *= s;
     }
@@ -284,10 +281,6 @@ namespace ngla
     void AddTo (TS s, BaseVector & v) const
     { 
       CheckSize (v);
-      /*
-      if (m.Height() != v.Size() || m.Width() != x.Size())
-	throw Exception ("matrix-vector MultAdd: size does not fit");
-      */
       m.MultAdd (s, x, v);
     }
 
@@ -849,7 +842,6 @@ namespace ngla
   {
     bool has_format;
     size_t size;
-    // bool is_complex;
   public:
     ///
     IdentityMatrix ()
@@ -857,7 +849,6 @@ namespace ngla
     IdentityMatrix (size_t asize, bool ais_complex)
       : has_format(true), size(asize) { is_complex=ais_complex; }
     
-    // virtual bool IsComplex() const override { return is_complex; }
     virtual BaseMatrix::OperatorInfo GetOperatorInfo () const override;
     
     ///
@@ -928,7 +919,7 @@ namespace ngla
   };
 
   
-  /* *********************** operator<< ********************** */
+  /* *********************** operators  ********************** */
 
   // default is ProductMatrix, but optimizations for
   // ParallelMatrices
@@ -954,8 +945,8 @@ namespace ngla
 
   
   shared_ptr<BaseMatrix> TransposeOperator (shared_ptr<BaseMatrix> mat);
+
   
-  /// output operator for matrices
   inline ostream & operator<< (ostream & ost, const BaseMatrix & m)
   {
     return m.Print(ost);

netgen/include/basevector.hpp

@@ -7,13 +7,34 @@
 /* Date:   7. Feb. 2003                                              */
 /*********************************************************************/
 
-
+#include <bla.hpp>
+#include <core/mpi_wrapper.hpp>
+// #include "paralleldofs.hpp"
 
 namespace ngla
 {
+  using namespace ngbla;
+  
   class BaseVector;
   class AutoVector;
   class MultiVector;
+
+  class ParallelDofs;
+  
+  class DofRange : public T_Range<size_t>
+  {
+    shared_ptr<ParallelDofs> pardofs;
+  public:
+    DofRange () { }
+    DofRange (T_Range<size_t> range, shared_ptr<ParallelDofs> apardofs)
+      : T_Range<size_t>(range), pardofs(apardofs) { ; }
+    DofRange (size_t end, shared_ptr<ParallelDofs> apardofs)
+      : T_Range<size_t>(0, end), pardofs(apardofs) { ; }
+    shared_ptr<ParallelDofs> GetParallelDofs() const { return pardofs; }
+  };
+  
+
+  
   
   template <class SCAL> class S_BaseVector;
 
@@ -91,9 +112,6 @@ namespace ngla
     size_t size;
     /// number of doubles per entry
     int entrysize = 1;
-    ///
-    // shared_ptr<ParallelDofs> paralleldofs;
-    
     ///
     BaseVector () { ; }
     
@@ -265,6 +283,7 @@ namespace ngla
     virtual void SetRandom ();
 
     inline AutoVector Range (size_t begin, size_t end) const;
+    inline AutoVector Range (size_t end) const;
     // { return Range(T_Range(begin, end)); }
     virtual AutoVector Range (T_Range<size_t> range) const;
     virtual AutoVector Range (DofRange range) const;
@@ -434,6 +453,7 @@ namespace ngla
     operator const BaseVector & () const { return *vec; }
 
     AutoVector Range (size_t begin, size_t end) const { return vec->Range(begin,end); }
+    AutoVector Range (size_t end) const { return vec->Range(0,end); }
     AutoVector Range (T_Range<size_t> range) const { return vec->Range(range); }
     
     template <typename T>
@@ -571,6 +591,11 @@ namespace ngla
     return Range(T_Range(begin, end));
   }
 
+  AutoVector BaseVector::Range (size_t end) const
+  {
+    return Range (0, end);
+  }
+  
 
   template <>
   inline FlatVector<double> BaseVector::FV<double> () const
@@ -651,72 +676,6 @@ namespace ngla
   extern template class S_BaseVector<Complex>;
 #endif
 
-  /*
-  template <class SCAL>
-  class NGS_DLL_HEADER S_BaseVector;
-
-
-  template <>
-  class NGS_DLL_HEADER S_BaseVector<double> : virtual public BaseVector
-  {
-  public:
-    S_BaseVector () throw () { ; }
-    virtual ~S_BaseVector() { ; }
-
-    S_BaseVector & operator= (double s);
-
-    virtual double InnerProduct (const BaseVector & v2) const;
-
-    virtual FlatVector<double> FVDouble () const;
-    virtual FlatVector<Complex> FVComplex () const;
-
-    virtual FlatVector<double> FVScal () const
-    {
-      return FlatVector<double> (size * entrysize, Memory());
-    }
-
-
-    virtual void GetIndirect (const FlatArray<int> & ind, 
-			      const FlatVector<double> & v) const;
-    virtual void GetIndirect (const FlatArray<int> & ind, 
-			      const FlatVector<Complex> & v) const;
-
-  };
-
-
-
-
-  template <>
-  class NGS_DLL_HEADER S_BaseVector<Complex> : virtual public BaseVector
-  {
-  public:
-    S_BaseVector () throw() { ; }
-    ~S_BaseVector () { ; }
-
-    virtual Complex InnerProduct (const BaseVector & v2) const;
-
-    virtual FlatVector<double> FVDouble () const throw();
-    virtual FlatVector<Complex> FVComplex () const throw();
-    virtual FlatVector<Complex> FVScal () const throw() 
-    {
-      return FlatVector<Complex> (size * entrysize/2, Memory());
-    }
-
-    virtual void GetIndirect (const FlatArray<int> & ind, 
-			      const FlatVector<double> & v) const;
-    virtual void GetIndirect (const FlatArray<int> & ind, 
-			      const FlatVector<Complex> & v) const;
-  };
-
-  */
-
-
-
-
-
-
-
-
 
 
 
@@ -821,14 +780,20 @@ namespace ngla
   };
 
 
-
+  /*
   inline VVecExpr<VSumExpr<VVecExpr<BaseVector>, VVecExpr<BaseVector> > >
   operator+ (const BaseVector & a, const BaseVector & b)
   {
     typedef VSumExpr<VVecExpr<BaseVector>, VVecExpr<BaseVector> > TRES;
     return TRES (a, b);
   }
+  */
+  inline auto operator+ (const BaseVector & a, const BaseVector & b)
+  {
+    return VVecExpr<VSumExpr<VVecExpr<BaseVector>,VVecExpr<BaseVector>>>{{a,b}};
+  }
 
+  /*
   template <class TA>
   inline VVecExpr<VSumExpr<VVecExpr<TA>, VVecExpr<BaseVector> > >
   operator+ (const VVecExpr<TA> & a, const BaseVector & b)
@@ -836,6 +801,13 @@ namespace ngla
     typedef VSumExpr<VVecExpr<TA>, VVecExpr<BaseVector> > TRES;
     return TRES (a, b);
   }
+  */
+  template <class TA>
+  inline auto operator+ (const VVecExpr<TA> & a, const BaseVector & b)
+  {
+    return VSumExpr<VVecExpr<TA>,VVecExpr<BaseVector>> (a,b);
+  }
+  
 
   template <class TB>
   inline VVecExpr<VSumExpr<VVecExpr<BaseVector>, VVecExpr<TB> > >

netgen/include/bilinearform.hpp

@@ -10,6 +10,9 @@
 
 #include "fespace.hpp"
 #include <specialelement.hpp>
+#include <sparsematrix.hpp>
+#include <elementbyelement.hpp>
+
 
 namespace ngcomp
 {
@@ -746,40 +749,6 @@ namespace ngcomp
 
 
 
-  template <class TM>
-  class NGS_DLL_HEADER T_BilinearFormDiagonal : public S_BilinearForm<typename mat_traits<TM>::TSCAL>
-  {
-
-  public:
-    typedef typename mat_traits<TM>::TSCAL TSCAL;
-    typedef typename mat_traits<TM>::TV_COL TV_COL;
-    typedef DiagonalMatrix<TM> TMATRIX;
-    shared_ptr<TMATRIX> mymatrix;
-    
-  protected:
-
-  public:
-    T_BilinearFormDiagonal (shared_ptr<FESpace> afespace, const string & aname,
-			    const Flags & flags);
-    virtual ~T_BilinearFormDiagonal ();
-
-    virtual void AllocateMatrix () override;
-
-    virtual void AddElementMatrix (FlatArray<int> dnums1,
-				   FlatArray<int> dnums2,
-				   BareSliceMatrix<TSCAL> elmat,
-				   ElementId id, bool addatomic, 
-				   LocalHeap & lh) override;
-
-    virtual void AddDiagElementMatrix (FlatArray<int> dnums1,
-				       FlatVector<TSCAL> diag,
-				       bool inner_element, int elnr,
-				       LocalHeap & lh) override;
-  };
-
-
-
-
 
   class ComponentBilinearForm : public BilinearForm
   {
@@ -953,17 +922,21 @@ namespace ngcomp
     Array<ProxyFunction*> trialproxies;
     
     typedef void (*lib_function)(size_t nip, double * input, size_t dist_input,
-                                 double * output, size_t dist_output);
+                                 double * output, size_t dist_output,
+                                 size_t dist, double * points, double * normals);
 
     unique_ptr<SharedLibrary> library;
     lib_function compiled_function = nullptr;
     
     size_t dimx, dimy;
     size_t nip;
+    Matrix<double> points;
+    Matrix<double> normals;
     
   public:
     ApplyIntegrationPoints (Array<shared_ptr<CoefficientFunction>> acoefs,
                             const Array<ProxyFunction*> & atrialproxies,
+                            Matrix<double> apoints, Matrix<double> anormals,
                             size_t adimx, size_t adimy, size_t anip);
     
     AutoVector CreateColVector() const override;
@@ -983,30 +956,6 @@ namespace ngcomp
   
 
   
-
-  /**
-     This bilinearform stores the element-matrices
-   */
-  template<class SCAL>
-  class ElementByElement_BilinearForm : public S_BilinearForm<SCAL>
-  {
-  public:
-    ElementByElement_BilinearForm (shared_ptr<FESpace> afespace, 
-                                   const string & aname,
-                                   const Flags & flags);
-    virtual ~ElementByElement_BilinearForm () override;
-    
-    virtual void AllocateMatrix () override;
-    // virtual AutoVector CreateRowVector() const override;
-    // virtual AutoVector CreateColVector() const override;
-    
-    virtual void AddElementMatrix (FlatArray<int> dnums1,
-                                   FlatArray<int> dnums2,
-                                   BareSliceMatrix<SCAL> elmat,
-                                   ElementId id, bool addatomic,
-                                   LocalHeap & lh) override;    
-  };
-  
   
   
 }

netgen/include/blockjacobi.hpp

@@ -7,6 +7,9 @@
 /* Date:   06. Oct. 96                                                     */
 /* *************************************************************************/
 
+
+#include "sparsematrix.hpp"
+
 namespace ngla
 {
 
@@ -172,6 +175,7 @@ namespace ngla
       return { MemoryUsage ("BlockJac", nels*sizeof(TM), blocktable->Size()) };
     }
 
+    virtual shared_ptr<BaseSparseMatrix> CreateSparseMatrix() const override;
     const Array<FlatMatrix<TM>> & GetInverses() const { return invdiag; }
     const Array<TM> & MatrixData() const { return bigmem; } 
   };

netgen/include/cg.hpp

@@ -8,6 +8,9 @@
 /* Date:   5. Jul. 96                                                     */
 /**************************************************************************/
 
+
+#include "basematrix.hpp"
+
 namespace ngla
 {
 

netgen/include/chebyshev.hpp

@@ -7,6 +7,9 @@
 /* Date:   30. Jun. 01                                                    */
 /**************************************************************************/
 
+
+#include "basematrix.hpp"
+
 namespace ngla
 {
 

netgen/include/comp.hpp

@@ -39,10 +39,6 @@ namespace ngmg
 
 
 #include <parallelngs.hpp>
-namespace ngcomp
-{
-  using namespace ngparallel;
-}
 
 
 // #include "pmltrafo.hpp"

netgen/include/diagonalmatrix.hpp

@@ -0,0 +1,154 @@
+#ifndef FILE_NGS_DIAGONALMATRIX
+#define FILE_NGS_DIAGONALMATRIX
+
+
+
+#include "basematrix.hpp"
+#include "vvector.hpp"
+
+
+namespace ngla
+{
+  
+  class NGS_DLL_HEADER Projector : public BaseMatrix
+  {
+    shared_ptr<BitArray> bits;
+    bool keep_values;
+  public:
+    // projector on true / false bits
+    Projector (shared_ptr<BitArray> abits, bool akeep_values = true)
+      : bits(abits), keep_values(akeep_values) { ; }
+    
+    virtual bool IsComplex() const override { return false; } 
+
+    virtual int VHeight() const override { return bits->Size(); }
+    virtual int VWidth() const override { return bits->Size(); }
+
+    virtual void Mult (const BaseVector & x, BaseVector & y) const override;    
+    virtual void MultTrans (const BaseVector & x, BaseVector & y) const override;
+    virtual void MultAdd (double s, const BaseVector & x, BaseVector & y) const override;    
+    virtual void MultTransAdd (double s, const BaseVector & x, BaseVector & y) const override;
+    virtual void Project (BaseVector & x) const;
+    virtual void SetValues (BaseVector & x, double val) const;
+
+    bool KeepValues() const { return keep_values; }
+    shared_ptr<BitArray> Mask() const { return bits; }
+
+    virtual shared_ptr<BaseSparseMatrix> CreateSparseMatrix() const override;
+    
+    AutoVector CreateRowVector() const override
+    { throw Exception("CreateRowVector not implemented for Projector!"); }
+    AutoVector CreateColVector() const override
+    { throw Exception("CreateColVector not implemented for Projector!"); }
+
+    AutoVector Evaluate(BaseVector & v) const override
+    {
+      auto res = v.CreateVector();
+      Mult (v, res);
+      return res;
+    }
+    
+  };
+
+
+  template <typename TM=double>
+  class NGS_DLL_HEADER DiagonalMatrix : public BaseMatrix
+  {
+    shared_ptr<VVector<TM>> diag;
+  public:
+    // typedef typename mat_traits<TM>::TV_ROW TV_ROW;
+    // typedef typename mat_traits<TM>::TV_COL TV_COL;
+    typedef typename mat_traits<TM>::TSCAL TSCAL;
+    
+    DiagonalMatrix(size_t h)
+      : diag(make_shared<VVector<TM>>(h)) { }
+    DiagonalMatrix(const VVector<TM> & diag_);
+    DiagonalMatrix(shared_ptr<VVector<TM>> diag_);
+    virtual ~DiagonalMatrix();
+    
+    bool IsComplex() const override { return false; } 
+    TM & operator() (size_t i) { return (*diag)(i); }
+    const TM & operator() (size_t i) const { return (*diag)(i); }
+    int VHeight() const override { return diag->Size(); }
+    int VWidth() const override { return diag->Size(); }
+
+    BaseVector & AsVector() override { return *diag; }
+    const BaseVector & AsVector() const override { return *diag; }
+    ostream & Print (ostream & ost) const override;
+
+    virtual shared_ptr<BaseSparseMatrix> CreateSparseMatrix() const override;
+    
+    AutoVector CreateRowVector () const override;
+    AutoVector CreateColVector () const override;
+
+    void MultAdd (double s, const BaseVector & x, BaseVector & y) const override;    
+    void MultTransAdd (double s, const BaseVector & x, BaseVector & y) const override;
+
+    shared_ptr<BaseMatrix> InverseMatrix (shared_ptr<BitArray> subset = nullptr) const override;
+  };
+
+
+  template <typename TM=double>  
+  class BlockDiagonalMatrix : public BaseMatrix
+  {
+    Tensor<3,TM> blockdiag;  
+    int blocks, dimy, dimx;
+  public:
+    // typedef double TSCAL;
+    
+    BlockDiagonalMatrix(Tensor<3,TM> _blockdiag);
+    bool IsComplex() const override { return ngbla::IsComplex<TM>(); } 
+
+    int VHeight() const override { return blocks*dimy; }
+    int VWidth() const override { return blocks*dimx; }
+
+    ostream & Print (ostream & ost) const override;
+    
+    AutoVector CreateRowVector () const override;
+    AutoVector CreateColVector () const override;
+
+    void Mult (const BaseVector & x, BaseVector & y) const override;    
+    void MultAdd (double s, const BaseVector & x, BaseVector & y) const override;    
+    void MultTransAdd (double s, const BaseVector & x, BaseVector & y) const override;
+
+    shared_ptr<BaseMatrix> InverseMatrix (shared_ptr<BitArray> subset = nullptr) const override;
+  };
+
+  // blocks is inner-most dimension of tensor and vectors
+  class BlockDiagonalMatrixSoA : public BaseMatrix
+  {
+    Tensor<3> blockdiag;  
+    int blocks, dimy, dimx;
+    Matrix<bool> nonzero;
+    Table<int> sparse, sparseT; // sparse non-zero pattern
+  public:
+    typedef double TSCAL;
+    
+    BlockDiagonalMatrixSoA(Tensor<3> _blockdiag);
+    bool IsComplex() const override { return false; } 
+
+    int VHeight() const override { return blocks*dimy; }
+    int VWidth() const override { return blocks*dimx; }
+
+    ostream & Print (ostream & ost) const override;
+    virtual BaseMatrix::OperatorInfo GetOperatorInfo () const override;
+    
+    AutoVector CreateRowVector () const override;
+    AutoVector CreateColVector () const override;
+
+    void Mult (const BaseVector & x, BaseVector & y) const override;    
+    void MultAdd (double s, const BaseVector & x, BaseVector & y) const override;
+    void MultTrans (const BaseVector & x, BaseVector & y) const override;    
+    void MultTransAdd (double s, const BaseVector & x, BaseVector & y) const override;
+    // shared_ptr<BaseMatrix> InverseMatrix (shared_ptr<BitArray> subset = nullptr) const override;
+
+    FlatTensor<3> GetBlockDiag () const { return blockdiag; }
+    FlatMatrix<bool> GetNonZeroPattern() const { return nonzero; }
+  };
+
+}
+
+
+
+#endif
+

netgen/include/dump.hpp

@@ -248,7 +248,7 @@ namespace ngstd
 
   template<typename DT, NODE_TYPE NT>
   void packaged_buffered_send(int rank, int np, DT* a, typename key_trait<NT>::TKEY* b, int n, int pkg_size, int p,
-			      Array<NG_MPI_Request> & requests)
+			      NgMPI_Requests & requests)
   {
     // NG_MPI_Datatype mpi_type_array = MPIT<DT>::mpi_type;
     NG_MPI_Datatype mpi_type_array = GetMPIType<DT>();
@@ -800,7 +800,7 @@ namespace ngstd
  
     if(rank == 0)
       {
-	Array<NG_MPI_Request> requests;
+	NgMPI_Requests requests;
 	//packaged_send
 	packaged_buffered_send<DT,NT>(rank, np, array, array_keys, base_array_size, pkg_size, 1, requests);
 
@@ -836,7 +836,7 @@ namespace ngstd
 
 	for(int j=0;(n_pkg-1)*pkg_size+j < n;j++)
 	  f(end_keys[j], end[j]);      
-	MyMPI_WaitAll (requests);
+	requests.WaitAll();
 	// free(end);
 	// free(end_keys);
       }
@@ -853,10 +853,10 @@ namespace ngstd
 	else //regular
 	  {
 	    //cout << "rank " << rank << " sends to " << rank+1 << " then gets from " << p_in1 << "/" << p_in2 << " and sends to " << p_out << endl;
-	    Array<NG_MPI_Request> requests;
+	    NgMPI_Requests requests;
 	    packaged_buffered_send<DT,NT>(rank, np, array, array_keys, base_array_size, pkg_size, rank+1, requests);
 	    merge_in_in_out<DT,NT>(pkg_size, rank, np, p_in1, p_in2, p_out);
-	    MyMPI_WaitAll (requests);
+	    requests.WaitAll();
 	  }
       }
     else

netgen/include/eigen.hpp

@@ -7,6 +7,9 @@
 /* Date:   5. Jul. 96                                                     */
 /**************************************************************************/
 
+
+#include "basematrix.hpp"
+
 namespace ngla
 {
 

netgen/include/elementbyelement.hpp

@@ -11,6 +11,10 @@
    Element by element matrix
 */
 
+
+#include "basematrix.hpp"
+#include "blockjacobi.hpp"
+
 namespace ngla
 {
 

netgen/include/elementtopology.hpp

@@ -14,9 +14,6 @@
 namespace ngfem
 {
   using namespace ngbla;
-  // using ngcore::INT;
-
-
   
   /*
     Toplogy of reference elements

netgen/include/expr.hpp

@@ -11,6 +11,7 @@
 #include <core/localheap.hpp>
 #include <core/exception.hpp>
 
+#include <cstddef>
 #include <ngs_stdcpp_include.hpp>  // for INLINE
 #include "complex_wrapper.hpp"
 
@@ -265,6 +266,7 @@ namespace ngbla
     explicit constexpr undefined_size(IC<S> s) : size(s) { }
     explicit constexpr operator size_t() const { return size; }
     explicit constexpr operator int() const { return size; }    
+    explicit constexpr operator ptrdiff_t() const { return size; }
   };