ngsolve 6.2.2406.post36.dev1__cp313-cp313-macosx_10_15_universal2.whl → 6.2.2406.post111.dev1__cp313-cp313-macosx_10_15_universal2.whl

netgen/include/hcurlhofespace.hpp

@@ -9,6 +9,7 @@
 
 #include "fespace.hpp"
 #include "h1hofespace.hpp"
+#include <sparsematrix.hpp>
 
 namespace ngcomp
 {
@@ -23,7 +24,7 @@ namespace ngcomp
   protected:
 
     typedef short TORDER;
-
+    
     // Level
     int level;
     Array<DofId> first_edge_dof;
@@ -58,7 +59,7 @@ namespace ngcomp
     bool usegrad;  
     bool var_order; 
   
-    int ndof;
+    // int ndof;
     int nedfine; 
     int uniform_order_inner;
     int uniform_order_face; 
@@ -95,7 +96,7 @@ namespace ngcomp
     ///
     virtual void DoArchive (Archive & archive) override;
     ///
-    virtual size_t GetNDof () const throw() override;
+    // virtual size_t GetNDof () const throw() override;
     virtual void SetOrder (NodeId ni, int order) override;
     virtual int GetOrder (NodeId ni) const override;
     using FESpace::GetOrder;

netgen/include/hdivfes.hpp

@@ -19,7 +19,7 @@ namespace ngcomp
   class RaviartThomasFESpace : public FESpace
   {
     ///
-    Array<int> ndlevel;
+    // Array<int> ndlevel;
   public:
     ///
     /*
@@ -42,9 +42,9 @@ namespace ngcomp
 
     virtual FiniteElement & GetFE (ElementId ei, Allocator & lh) const override;
     ///
-    virtual size_t GetNDof () const throw() override;
+    // virtual size_t GetNDof () const throw() override;
     ///
-    virtual size_t GetNDofLevel (int level) const override;
+    // virtual size_t GetNDofLevel (int level) const override;
 
     ///
     virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;

netgen/include/hdivhosurfacefespace.hpp

@@ -15,7 +15,7 @@ namespace ngcomp
   {
   protected:
     
-    int ndof;
+    // int ndof;
     
     Array<DofId> first_facet_dof;
     Array<DofId> first_inner_dof;
@@ -28,7 +28,7 @@ namespace ngcomp
     Array<bool> fine_facet; 
     Array<bool> boundary_facet; 
  
-    Array<int> ndlevel;
+    // Array<int> ndlevel;
     int uniform_order_inner; 
     int uniform_order_facet; 
 
@@ -64,7 +64,7 @@ namespace ngcomp
     virtual void UpdateDofTables() override; 
     virtual void UpdateCouplingDofArray() override;   
     
-    virtual size_t GetNDof () const throw() override;
+    // virtual size_t GetNDof () const throw() override;
     
     virtual FiniteElement & GetFE (ElementId ei, Allocator & alloc) const override;            
 

netgen/include/intrule.hpp

@@ -436,7 +436,7 @@ namespace ngfem
     INLINE SCAL operator() (int i) const { return point(i); }
 
     ///
-    INLINE const Vec<R,SCAL> GetNV () const { return normalvec; }
+    INLINE const Vec<R,SCAL> & GetNV () const { return normalvec; }
     /// 
     INLINE void SetNV ( Vec<R,SCAL> vec) { normalvec = vec; }
     ///
@@ -1481,6 +1481,7 @@ namespace ngfem
     int DimSpace() const;
     
     virtual SliceMatrix<> GetPoints() const = 0;
+    virtual SliceMatrix<> GetNormals() const = 0;    
     virtual SliceMatrix<Complex> GetPointsComplex() const
     { throw Exception("don't have complex ir"); }
     virtual void ComputeNormalsAndMeasure (ELEMENT_TYPE et) { throw Exception ("ComputeNormalsAndMeasure(ET) not overloaded"); }
@@ -1551,6 +1552,13 @@ namespace ngfem
                             const_cast<double*> (&mips[0].GetPoint()(0)));
     }
 
+    virtual SliceMatrix<> GetNormals() const
+    {
+      return SliceMatrix<> (mips.Size(), DIM_SPACE*sizeof(SCAL)/sizeof(double),
+                            sizeof(MappedIntegrationPoint<DIM_ELEMENT, DIM_SPACE, SCAL>) / sizeof(double),
+                            const_cast<double*> (&mips[0].GetNV()(0)));
+    }
+
     virtual void ComputeNormalsAndMeasure (ELEMENT_TYPE et);
     virtual void ComputeNormalsAndMeasure (ELEMENT_TYPE et, int facetnr);
     virtual bool IsComplex() const { return false; } 
@@ -1616,6 +1624,12 @@ namespace ngfem
                                    const_cast<Complex*> (&mips[0].GetPointComplex()(0)));
     }
 
+    virtual SliceMatrix<> GetNormals() const
+    {
+      throw Exception("never tested");
+    }
+    
+
     virtual void ComputeNormalsAndMeasure (ELEMENT_TYPE et, int facetnr);
     virtual bool IsComplex() const { return true; }     
   };

netgen/include/jacobi.hpp

@@ -7,6 +7,9 @@
 /* Date:   06. Oct. 96                                                    */
 /* *************************************************************************/
 
+
+#include "sparsematrix.hpp"
+
 namespace ngla
 {
 

netgen/include/la.hpp

@@ -2,15 +2,6 @@
 #define FILE_NGLA
 
 #include <bla.hpp>
-#include <core/mpi_wrapper.hpp>
-
-/*
-namespace ngcomp
-{
-  class Preconditioner;
-  class LocalPreconditioner;
-}
-*/
 
 /** namespace for linear algebra.
  */
@@ -33,13 +24,10 @@ namespace ngla
 #include "order.hpp"
 #include "sparsecholesky.hpp"
 #include "pardisoinverse.hpp"
-// include these only from c++-files
-// #include "umfpackinverse.hpp"
-// #include "superluinverse.hpp"
-// #include "mumpsinverse.hpp"
 #include "jacobi.hpp"
 #include "blockjacobi.hpp"
 #include "commutingAMG.hpp"
+#include "diagonalmatrix.hpp"
 #include "special_matrix.hpp"
 #include "elementbyelement.hpp"
 #include "cg.hpp"

netgen/include/matrix.hpp

@@ -243,11 +243,21 @@ namespace ngbla
       return FlatMatrix (next-first, w, data+first*w);
     }
 
+    INLINE FlatMatrix Rows (size_t next) const
+    {
+      return FlatMatrix (next, w, data);
+    }
+
     INLINE SliceMatrix<T> Cols (size_t first, size_t next) const
     {
       return SliceMatrix<T> (h, next-first, w, data+first);
     }
 
+    INLINE SliceMatrix<T> Cols (size_t next) const
+    {
+      return SliceMatrix<T> (h, next, w, data);
+    }
+
     INLINE FlatMatrix Rows (IntRange range) const
     {
       return FlatMatrix (range.Next()-range.First(), w, data+range.First()*w);
@@ -1356,6 +1366,12 @@ namespace ngbla
         return MatrixView<T,ORD,TH,size_t,TDIST>  (h, next-first, Dist(), Addr(0,first));
     }
 
+    INLINE auto Cols (size_t next) const
+    {
+      return Cols(0, next);
+    }
+
+    
     INLINE auto Rows (size_t first, size_t next) const
     {
       if constexpr (ORD==RowMajor)
@@ -1369,6 +1385,11 @@ namespace ngbla
       return Rows (range.First(), range.Next());
     }
 
+    INLINE auto Rows (size_t next) const
+    {
+      return Rows (0, next);
+    }
+
     template <int R>
     INLINE auto Rows() const
     {

netgen/include/meshaccess.hpp

@@ -9,8 +9,6 @@
 
 
 #include <nginterface_v2.hpp>
-#include <core/ranges.hpp>
-
 #include <elementtopology.hpp>
 
 namespace ngfem
@@ -26,7 +24,6 @@ namespace ngcomp
 {
   class PML_Transformation;
   
-  // using ngcore::INT;
   using netgen::Ng_Node;
   using ngfem::ELEMENT_TYPE;
   
@@ -158,30 +155,6 @@ namespace ngcomp
     INLINE auto end () const { return DimElementIterator<VB,DIM>(ma, r.Next()); }
   };
 
-  /*
-  class NodeIterator
-  {
-    NodeId ni;
-  public:
-    NodeIterator (NodeId ani) : ni(ani) { ; }
-    NodeIterator operator++ () { return NodeIterator(++ni); }
-    INLINE NodeId operator*() const { return ni; }
-    bool operator!=(NodeIterator id2) const { return ni != id2.ni; }
-    bool operator==(NodeIterator id2) const { return ni == id2.ni; }
-  };
-
-  class NodeRange : public IntRange
-  {
-    NODE_TYPE nt;
-  public:
-    NodeRange (NODE_TYPE ant, IntRange ar) 
-      : IntRange(ar), nt(ant) { ; } 
-    NodeIterator begin () const { return NodeIterator(NodeId(nt,IntRange::First())); }
-    NodeIterator end () const { return NodeIterator(NodeId(nt,IntRange::Next())); }
-    NodeId operator[] (size_t nr) { return NodeId(nt, IntRange::First()+nr); }
-  };
-  */
-
   /** 
       Access to mesh topology and geometry.
 
@@ -240,9 +213,12 @@ namespace ngcomp
 
     /// store periodic vertex mapping for each identification number
     // shared ptr because Meshaccess is copy constructible
+    /*
     shared_ptr<Array<Array<IVec<2>>>> periodic_node_pairs[3] = {make_shared<Array<Array<IVec<2>>>>(),
                                                                make_shared<Array<Array<IVec<2>>>>(),
                                                                make_shared<Array<Array<IVec<2>>>>()};
+    */
+    Array<Array<IVec<2>>> periodic_node_pairs[3];
 
     DynamicTable<size_t> neighbours[4][4];
     friend class Region;
@@ -662,7 +638,7 @@ namespace ngcomp
     
     void SetDeformation (shared_ptr<GridFunction> def = nullptr);
 
-    const shared_ptr<GridFunction> & GetDeformation () const
+    shared_ptr<GridFunction> GetDeformation () const
     {
       return deformation;
     }
@@ -817,15 +793,6 @@ namespace ngcomp
     void GetFaceEdges (int fnr, Array<int> & edges) const;
     INLINE auto GetFaceEdges (size_t fnr) const
     { return ArrayObject(mesh.GetFaceEdges(fnr)); }
-    /*
-    {
-      ArrayMem<int,4> f2ed;
-      GetFaceEdges (fnr, f2ed);
-      f2ed.NothingToDelete(); // dynamic allocation never needed
-      return f2ed;
-    }
-    */
-    
     void GetEdgeFaces (int enr, Array<int> & faces) const;
     /// returns elements connected to a face
     void GetFaceElements (int fnr, Array<int> & elnums) const;
@@ -911,7 +878,6 @@ namespace ngcomp
     }
 
 
-    // void GetVertexElements (int vnr, Array<int> & elnrs) const;
     /// element order stored in Netgen
     int GetElOrder (int enr) const
     { return mesh.GetElementOrder (enr+1); } 
@@ -1053,11 +1019,11 @@ namespace ngcomp
 	}
     }
     
-
+    /*
     // (old style optimization)
     [[deprecated("functionality not useful anymore, just remove function call!")]]            
     void SetPointSearchStartElement(const int el) const;
-
+    */
 
     
     ElementId FindElementOfPoint (FlatVector<double> point,
@@ -1083,6 +1049,7 @@ namespace ngcomp
     { return GetElement(ElementId(VOL,elnr)).is_curved; }
       // { return bool (Ng_IsElementCurved (elnr+1)); }
 
+    /*
     [[deprecated("Use GetPeriodicNodes(NT_VERTEX, pairs) instead!")]]
     void GetPeriodicVertices ( Array<IVec<2> > & pairs) const;
     [[deprecated("Use GetNPeriodicNodes(NT_VERTEX) instead!")]]
@@ -1100,10 +1067,11 @@ namespace ngcomp
     void GetPeriodicEdges (int idnr, Array<IVec<2> > & pairs) const;
     [[deprecated("Use GetPeriodicNodes(NT_EDGE, idnr).Size() instead")]]
     int GetNPairsPeriodicEdges (int idnr) const;
-
+    */
+    
     int GetNPeriodicIdentifications() const
     {
-      return periodic_node_pairs[NT_VERTEX]->Size();
+      return periodic_node_pairs[NT_VERTEX].Size();
     }
     // get number of all periodic nodes of nodetype nt
     size_t GetNPeriodicNodes(NODE_TYPE nt) const;
@@ -1147,9 +1115,10 @@ namespace ngcomp
 
     // void PrecomputeGeometryData(int intorder);
 
+    /*
     void InitPointCurve(double red = 1, double green = 0, double blue = 0) const;
     void AddPointCurvePoint(const Vec<3> & point) const;
-
+    */
 
     
     template <int DIMS, int DIMR> friend class Ng_ElementTransformation;
@@ -1169,10 +1138,11 @@ namespace ngcomp
        Returns the global number of the node.
        Currently, this function works only for vertex-nodes.
      */
-
+    /*
     [[deprecated("should not need global numbers")]]                    
     size_t GetGlobalNodeNum (NodeId node) const;
-
+    */
+    
     size_t GetGlobalVertexNum (int locnum) const;
     
     FlatArray<int> GetDistantProcs (NodeId node) const

netgen/include/mgpre.hpp

@@ -9,7 +9,7 @@
 /*********************************************************************/
 
 #include <bilinearform.hpp>
-#include <la.hpp>
+// #include <la.hpp>
 
 namespace ngmg
 {

netgen/include/multivector.hpp

@@ -7,6 +7,8 @@
 /* Date:   June 2020                                                 */
 /*********************************************************************/
 
+#include "basevector.hpp"
+
 namespace ngla {
 
   /* TODO: 

netgen/include/ngsobject.hpp

@@ -2,7 +2,7 @@
 #define FILE_NGSOBJECT
 
 /*********************************************************************/
-/* File:   ngsobject.hh                                              */
+/* File:   ngsobject.hpp                                             */
 /* Author: Joachim Schoeberl                                         */
 /* Date:   2. Aug. 2000                                              */
 /*********************************************************************/

netgen/include/normalfacetfespace.hpp

@@ -25,8 +25,8 @@ namespace ngcomp
     Array<IVec<2> > order_facet;
     Array<bool> fine_facet;
 
-    int ndof;
-    Array<int> ndlevel;
+    // int ndof;
+    // Array<int> ndlevel;
     bool var_order;
     bool print;
 
@@ -51,9 +51,8 @@ namespace ngcomp
     virtual void SetOrder (NodeId ni, int order) override;
     virtual int GetOrder (NodeId ni) const override;
     
-    virtual size_t GetNDof() const throw() override { return ndof; }
-
-    virtual size_t GetNDofLevel ( int i ) const override { return ndlevel[i]; }
+    // virtual size_t GetNDof() const throw() override { return ndof; }
+    // virtual size_t GetNDofLevel ( int i ) const override { return ndlevel[i]; }
 
     virtual FlatArray<VorB> GetDualShapeNodes (VorB vb) const override;
 

netgen/include/order.hpp

@@ -2,7 +2,7 @@
 #define FILE_ORDER
 
 /* *************************************************************************/
-/* File:   order.hh                                                       */
+/* File:   order.hpp                                                      */
 /* Author: Joachim Schoeberl                                              */
 /* Date:   18. Jun. 97                                                    */
 /* *************************************************************************/
@@ -10,6 +10,8 @@
 
 namespace ngla
 {
+  using namespace ngcore;
+  using namespace ngstd;  
 
   /*
     reordering for sparse cholesky factoriztion

netgen/include/parallel_matrices.hpp

@@ -7,6 +7,11 @@
 /* Date:   2007,2011                                                      */
 /* ************************************************************************/
 
+
+#include <basematrix.hpp>
+#include <sparsematrix.hpp>
+#include <paralleldofs.hpp>
+
 namespace ngla
 {
 

netgen/include/paralleldofs.hpp

@@ -8,10 +8,14 @@
 /**************************************************************************/
 
 
+#include <core/mpi_wrapper.hpp>
+#include <ngstd.hpp>
 
 namespace ngla
 {
+  using namespace ngstd;
 
+  
 #ifdef PARALLEL
 
   /**
@@ -133,7 +137,7 @@ namespace ngla
   public:
     ParallelDofs (NgMPI_Comm acomm, Table<int> && adist_procs, 
 		  int dim = 1, bool iscomplex = false)
-      : es(dim), complex(iscomplex)
+      : ndof(adist_procs.Size()), es(dim), complex(iscomplex)
     { ; }
     
     int GetNDofLocal () const { return ndof; }
@@ -223,18 +227,6 @@ namespace ngla
     nrecv = 0;
 
     /** Count send/recv size **/
-    /*
-    for (int i = 0; i < GetNDofLocal(); i++) {
-      auto dps = GetDistantProcs(i);
-      if(!dps.Size()) continue;
-      int master = min2(rank, dps[0]);
-      if(rank==master)
-	for(auto p:dps)
-	  nrecv[p]++;
-      else
-	nsend[master]++;
-    }
-    */
     for (int i = 0; i < GetNDofLocal(); i++)
       if (auto dps = GetDistantProcs(i); dps.Size())
         {
@@ -244,55 +236,39 @@ namespace ngla
           else
             nsend[dps[0]]++;
         }
-
     
     Table<T> send_data(nsend);
     Table<T> recv_data(nrecv);
 
     /** Fill send_data **/
     nsend = 0;
-    /*
-    for (int i = 0; i < GetNDofLocal(); i++) {
-      auto dps = GetDistantProcs(i);
-      if(!dps.Size()) continue;
-      int master = min2(rank, dps[0]);
-      if(master!=rank)
-	send_data[master][nsend[master]++] = data[i];
-    }
-    */
     for (int i = 0; i < GetNDofLocal(); i++)
       if (auto dps = GetDistantProcs(i); dps.Size())
         if (rank > dps[0])
           send_data[dps[0]][nsend[dps[0]]++] = data[i];
 
-    NgMPI_Requests requests; 
+    NgMPI_Requests send_requests; 
+    NgMPI_Requests recv_requests; 
     for (int i = 0; i < ntasks; i++)
       {
 	if (nsend[i])
-	  requests += comm.ISend(send_data[i], i, NG_MPI_TAG_SOLVE);
+	  send_requests += comm.ISend(send_data[i], i, NG_MPI_TAG_SOLVE);
 	if (nrecv[i])
-	  requests += comm.IRecv(recv_data[i], i, NG_MPI_TAG_SOLVE);
+	  recv_requests += comm.IRecv(recv_data[i], i, NG_MPI_TAG_SOLVE);
       }
-    requests.WaitAll();
 
     Array<int> cnt(ntasks);
     cnt = 0;
     
     NG_MPI_Datatype type = GetMPIType<T>();
-    /*
-    for (int i = 0; i < GetNDofLocal(); i++)
-      if (IsMasterDof(i))
-	{
-	  FlatArray<int> distprocs = GetDistantProcs (i);
-	  for (int j = 0; j < distprocs.Size(); j++)
-	    NG_MPI_Reduce_local (&recv_data[distprocs[j]][cnt[distprocs[j]]++], 
-                                 &data[i], 1, type, op);
-	}
-    */
+
+    recv_requests.WaitAll();
     for (int i = 0; i < GetNDofLocal(); i++)
       if (IsMasterDof(i))
         for (auto p : GetDistantProcs (i))
           NG_MPI_Reduce_local (&recv_data[p][cnt[p]++], &data[i], 1, type, op);
+
+    send_requests.WaitAll();    
   }    
 
 
@@ -359,20 +335,6 @@ namespace ngla
 
 #endif //PARALLEL
 
-
-  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) { ; }
-    shared_ptr<ParallelDofs> GetParallelDofs() const { return pardofs; }
-  };
-  
-
 }
 
-
-
 #endif

netgen/include/parallelngs.hpp

@@ -1,6 +1,7 @@
 #ifndef FILE_PARALLELNGS
 #define FILE_PARALLELNGS
 
+/*
 #include <ngstd.hpp>
 #include <la.hpp>
 
@@ -9,7 +10,7 @@ namespace ngparallel
   using namespace ngstd;
   using namespace ngla;
 }
-
+*/
 
 #include "parallelvector.hpp"
 #include "parallel_matrices.hpp"

netgen/include/parallelvector.hpp

@@ -7,10 +7,13 @@
 /* Date:   2007,2011                                                      */
 /* ************************************************************************/
 
-
+#include <vvector.hpp>
+#include <multivector.hpp>
+#include <paralleldofs.hpp>
 
 namespace ngla
 {
+  
   class NGS_DLL_HEADER ParallelBaseVector : virtual public BaseVector
   {
   protected:
@@ -169,7 +172,7 @@ namespace ngla
     using ParallelBaseVector :: sreqs;
     using ParallelBaseVector :: rreqs;
 
-    Table<SCAL> * recvvalues;
+    Table<SCAL> recvvalues;
 
     using S_BaseVectorPtr<TSCAL> :: pdata;
     using ParallelBaseVector :: local_vec;

netgen/include/pardisoinverse.hpp

@@ -15,6 +15,7 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
+#include "sparsecholesky.hpp"  // for SparseFactorization
 
 namespace ngla
 {

netgen/include/periodic.hpp

@@ -80,6 +80,7 @@ namespace ngcomp
     { space->VTransformVC(ei, vec, tt); }    
 
     auto & GetVertexMap() const { return vertex_map; }
+    auto & GetDofMap() const { return dofmap; }    
   protected:
     // overload in quasiperiodic space
     virtual void DofMapped(size_t from, size_t to, size_t idnr) { ; }

netgen/include/preconditioner.hpp

@@ -7,8 +7,10 @@
 /* Date:   10. Jul. 2000                                             */
 /*********************************************************************/
 
-#include <la.hpp>
+// #include <la.hpp>
+#include <basematrix.hpp>
 #include <mgpre.hpp>
+#include <chebyshev.hpp>
 
 namespace ngcomp
 {

netgen/include/sparsecholesky.hpp

@@ -11,6 +11,10 @@
   sparse cholesky factorization
 */
 
+#include "basematrix.hpp"
+#include "sparsematrix.hpp"
+#include "order.hpp"
+
 namespace ngla
 {