ngsolve 6.2.2406__cp312-cp312-win_amd64.whl → 6.2.2406.post111.dev1__cp312-cp312-win_amd64.whl

netgen/include/paralleldofs.hpp

@@ -8,10 +8,14 @@
 /**************************************************************************/
 
 
+#include <core/mpi_wrapper.hpp>
+#include <ngstd.hpp>
 
 namespace ngla
 {
+  using namespace ngstd;
 
+  
 #ifdef PARALLEL
 
   /**
@@ -54,7 +58,7 @@ namespace ngla
        Table adist_procs must provide the distant processes for each dof.
        table 
      */
-    ParallelDofs (NG_MPI_Comm acomm, Table<int> && adist_procs, 
+    ParallelDofs (NgMPI_Comm acomm, Table<int> && adist_procs, 
 		  int dim = 1, bool iscomplex = false);
 
     shared_ptr<ParallelDofs> SubSet (shared_ptr<BitArray> take_dofs) const;
@@ -131,9 +135,9 @@ namespace ngla
     bool complex;
     BitArray masterdofs;
   public:
-    ParallelDofs (NG_MPI_Comm acomm, Table<int> && adist_procs, 
+    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; }
@@ -174,42 +178,41 @@ namespace ngla
   };
   
 #endif
+  
 
-
-
+  
   template <typename T>
+  [[deprecated("use pardofs.ReduceDofData")]]
   void ReduceDofData (FlatArray<T> data, NG_MPI_Op op, const shared_ptr<ParallelDofs> & pardofs)
   {
     if (pardofs)
       pardofs->ReduceDofData(data, op);
   }
-
+  
   template <typename T>
+  [[deprecated("use pardofs.ScatterDofData")]]   
   void ScatterDofData (FlatArray<T> data, const shared_ptr<ParallelDofs> & pardofs)
   {
     if (pardofs)
       pardofs->ScatterDofData (data);
   }
-
+  
   template <typename T>
+  [[deprecated("use pardofs.AllReduceDofData")]]
   void AllReduceDofData (FlatArray<T> data, NG_MPI_Op op, 
 			 const shared_ptr<ParallelDofs> & pardofs)
   {
     if (pardofs)
       pardofs->AllReduceDofData (data, op);
   }
-
-
+  
 
 
 #ifdef PARALLEL
 
   template <typename T>
-  void ParallelDofs::ReduceDofData (FlatArray<T> data, NG_MPI_Op op) const
+  void ParallelDofs :: ReduceDofData (FlatArray<T> data, NG_MPI_Op op) const
   {
-    // if (this == NULL)  // illformed C++, shall get rid of this
-    // throw Exception("ReduceDofData for null-object");
-    
     static Timer t0("ParallelDofs :: ReduceDofData");
     RegionTimer rt(t0);
 
@@ -224,53 +227,48 @@ 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())
+        {
+          if (rank < dps[0])
+            for (auto p : dps)
+              nrecv[p]++;
+          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];
 
-    Array<NG_MPI_Request> requests; 
+    NgMPI_Requests send_requests; 
+    NgMPI_Requests recv_requests; 
     for (int i = 0; i < ntasks; i++)
       {
 	if (nsend[i])
-	  requests.Append (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.Append (comm.IRecv(recv_data[i], i, NG_MPI_TAG_SOLVE));
+	  recv_requests += comm.IRecv(recv_data[i], i, NG_MPI_TAG_SOLVE);
       }
 
-    MyMPI_WaitAll (requests);
-
     Array<int> cnt(ntasks);
     cnt = 0;
     
     NG_MPI_Datatype type = GetMPIType<T>();
+
+    recv_requests.WaitAll();
     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);
-	}
+        for (auto p : GetDistantProcs (i))
+          NG_MPI_Reduce_local (&recv_data[p][cnt[p]++], &data[i], 1, type, op);
+
+    send_requests.WaitAll();    
   }    
 
 
@@ -293,18 +291,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)
-	  nsend[p]++;
-      else
-	nrecv[master]++;
-    }
-    */
     for (int i = 0; i < GetNDofLocal(); i++) 
       if (auto dps = GetDistantProcs(i); dps.Size() > 0)
         {
@@ -320,48 +306,25 @@ namespace ngla
 
     /** 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(rank==master)
-	for(auto p:dps)
-	  send_data[p][nsend[p]++] = data[i];
-    }
-    */
     for (int i = 0; i < GetNDofLocal(); i++) 
       if (auto dps = GetDistantProcs(i); dps.Size() > 0)
         if (rank < dps[0])
           for (auto p : dps)
             send_data[p][nsend[p]++] = data[i];
     
-    Array<NG_MPI_Request> requests;
+    NgMPI_Requests requests;
     for (int i = 0; i < ntasks; i++)
       {
 	if (nsend[i])
-	  requests.Append (comm.ISend (send_data[i], i, NG_MPI_TAG_SOLVE));
+	  requests += comm.ISend (send_data[i], i, NG_MPI_TAG_SOLVE);
 	if (nrecv[i])
-	  requests.Append (comm.IRecv (recv_data[i], i, NG_MPI_TAG_SOLVE));
+	  requests += comm.IRecv (recv_data[i], i, NG_MPI_TAG_SOLVE);
       }
-
-    MyMPI_WaitAll (requests);
+    requests.WaitAll();
 
     Array<int> cnt(ntasks);
     cnt = 0;
 
-    /*
-    for (int i = 0; i < GetNDofLocal(); i++)
-      if (!IsMasterDof(i))
-	{
-	  FlatArray<int> distprocs = GetDistantProcs (i);
-	  
-	  int master = ntasks;
-	  for (int j = 0; j < distprocs.Size(); j++)
-	    master = min (master, distprocs[j]);
-	  data[i] = recv_data[master][cnt[master]++];
-	}
-    */
     for (int i = 0; i < GetNDofLocal(); i++)
       if (!IsMasterDof(i))
 	{
@@ -372,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,16 +7,13 @@
 /* Date:   2007,2011                                                      */
 /* ************************************************************************/
 
-
-
-// #ifdef PARALLEL
+#include <vvector.hpp>
+#include <multivector.hpp>
+#include <paralleldofs.hpp>
 
 namespace ngla
 {
-  // using ngparallel::ParallelDofs;
-  // using ngla::ParallelDofs;
-
-
+  
   class NGS_DLL_HEADER ParallelBaseVector : virtual public BaseVector
   {
   protected:
@@ -24,8 +21,8 @@ namespace ngla
     shared_ptr<ParallelDofs> paralleldofs;    
     shared_ptr<BaseVector> local_vec;
     
-    Array<NG_MPI_Request> sreqs;
-    Array<NG_MPI_Request> rreqs;
+    mutable NgMPI_Requests sreqs;
+    mutable NgMPI_Requests rreqs;
 
   public:
     ParallelBaseVector ()
@@ -86,10 +83,10 @@ namespace ngla
     virtual void Distribute() const override = 0;
     // { cerr << "ERROR -- Distribute called for BaseVector, is not parallel" << endl; }
     
-    virtual void ISend ( int dest, NG_MPI_Request & request ) const;
+    virtual NgMPI_Request ISend ( int dest ) const;
     // virtual void Send ( int dest ) const;
     
-    virtual void IRecvVec ( int dest, NG_MPI_Request & request ) = 0;
+    virtual NgMPI_Request IRecvVec ( int dest ) = 0;
     // { cerr << "ERROR -- IRecvVec called for BaseVector, is not parallel" << endl; }
 
     // virtual void RecvVec ( int dest )
@@ -105,7 +102,6 @@ namespace ngla
 
 
 
-
   inline ParallelBaseVector * dynamic_cast_ParallelBaseVector (BaseVector * x)
   {
     // cout << "my dynamic * cast" << endl;
@@ -126,7 +122,7 @@ namespace ngla
       }
     return dynamic_cast<const ParallelBaseVector*> (x);
   }
-  
+
   inline ParallelBaseVector & dynamic_cast_ParallelBaseVector (BaseVector & x)
   {
     // cout << "my dynamic cast" << endl;
@@ -135,6 +131,7 @@ namespace ngla
       return dynamic_cast<ParallelBaseVector&> (**ax);
     return dynamic_cast<ParallelBaseVector&> (x);
   }
+
   inline const ParallelBaseVector & dynamic_cast_ParallelBaseVector (const BaseVector & x)
   {
     // cout << "my dynamic cast" << endl;
@@ -175,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;
@@ -192,7 +189,7 @@ namespace ngla
     virtual AutoVector Range (T_Range<size_t> range) const override;
     virtual AutoVector Range (DofRange range) const override;
     
-    virtual void  IRecvVec ( int dest, NG_MPI_Request & request ) override;
+    virtual NgMPI_Request IRecvVec ( int dest ) override;
     // virtual void  RecvVec ( int dest );
     virtual void AddRecvValues( int sender ) override;
     virtual AutoVector CreateVector () const override;
@@ -269,5 +266,4 @@ namespace ngla
   
 }
 
-// #endif
 #endif

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/pmltrafo.hpp

@@ -298,13 +298,16 @@ namespace ngcomp
     Complex alpha;
     public:
 
-    CartesianPML_Transformation(FlatMatrix<double> _bounds, Complex _alpha) 
-      : PML_TransformationDim<DIM>(), alpha(_alpha) 
+    CartesianPML_Transformation(Mat<DIM,2> _bounds, Complex _alpha) 
+      : PML_TransformationDim<DIM>(), bounds(_bounds), alpha(_alpha)
     {
+      /*
       bounds = 0.;
       for (int i : Range(min(int(_bounds.Height()),DIM)))
         for (int j : Range(min(int(_bounds.Width()),2)))
           bounds(i,j)=_bounds(i,j);
+      */
+      ;
     }
     
     ~CartesianPML_Transformation() {;}

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/scalarfe.hpp

@@ -288,6 +288,9 @@ namespace ngfem
     { 
       for (int i = 0; i < avnums.Size(); i++) vnums[i] = avnums[i]; 
     }
+    DGFiniteElement * SetVertexNumbers (FlatArray<int> vnums) override
+    { VertexOrientedFE<ET>::SetVertexNumbers(vnums); return this; }
+    
 
     /// assign vertex number
     void SetVertexNumber (int nr, int vnum) { vnums[nr] = vnum; }
@@ -301,7 +304,7 @@ namespace ngfem
     NGS_DLL_HEADER void CalcTraceMatrix (int facet, FlatMatrix<> trace) const;
     NGS_DLL_HEADER void CalcGradientMatrix (FlatMatrix<> gmat) const;
 
-    HD NGS_DLL_HEADER virtual void GetDiagMassMatrix (FlatVector<> mass) const;
+    HD NGS_DLL_HEADER virtual void GetDiagMassMatrix (FlatVector<> mass) const override;
 
     NGS_DLL_HEADER virtual void GetGradient (FlatVector<> coefs, FlatMatrixFixWidth<D> grad) const;
     NGS_DLL_HEADER virtual void GetGradientTrans (FlatMatrixFixWidth<D> grad, FlatVector<> coefs) const;

netgen/include/sparsecholesky.hpp

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

netgen/include/sparsematrix.hpp

@@ -8,6 +8,9 @@
 /**************************************************************************/
 
 
+#include "vvector.hpp"
+#include "basematrix.hpp"
+
 namespace ngla
 {
 
@@ -555,7 +558,7 @@ namespace ngla
     virtual tuple<int,int> EntrySizes() const override { return { ngbla::Height<TM>(), ngbla::Width<TM>() }; }
     
     shared_ptr<BaseSparseMatrix>
-      CreateTransposeTM (const function<shared_ptr<SparseMatrixTM<decltype(Trans(TM()))>>(const Array<int>&, int)> & creator) const;
+      CreateTransposeTM (const function<shared_ptr<SparseMatrixTM<decltype(ngbla::Trans(TM()))>>(const Array<int>&, int)> & creator) const;
 
   public:
     using BaseMatrix::GetMemoryTracer;
@@ -616,37 +619,13 @@ namespace ngla
     { return { string("SparseMatrix")+typeid(TM).name(), this->Height(), this->Width() }; }
     
     virtual shared_ptr<BaseJacobiPrecond>
-      CreateJacobiPrecond (shared_ptr<BitArray> inner) const override
-    {
-      // if constexpr(mat_traits<TM>::HEIGHT != mat_traits<TM>::WIDTH) return nullptr;
-      if constexpr(ngbla::Height<TM>() != ngbla::Width<TM>()) return nullptr;
-      else if constexpr(ngbla::Height<TM>() > MAX_SYS_DIM) {
-	  throw Exception(string("MAX_SYS_DIM = ")+to_string(MAX_SYS_DIM)+string(", need ")+to_string(mat_traits<TM>::HEIGHT));
-	  return nullptr;
-	}
-      else return make_shared<JacobiPrecond<TM,TV_ROW,TV_COL>> (*this, inner);
-    }
+      CreateJacobiPrecond (shared_ptr<BitArray> inner) const override;
     
     virtual shared_ptr<BaseBlockJacobiPrecond>
       CreateBlockJacobiPrecond (shared_ptr<Table<int>> blocks,
                                 const BaseVector * constraint = 0,
                                 bool parallel = 1,
-                                shared_ptr<BitArray> freedofs = NULL) const override
-    { 
-      // if constexpr(mat_traits<TM>::HEIGHT != mat_traits<TM>::WIDTH) return nullptr;
-      if constexpr(ngbla::Height<TM>() != ngbla::Width<TM>()) return nullptr;
-      else if constexpr(ngbla::Height<TM>() > MAX_SYS_DIM) {
-	  throw Exception(string("MAX_SYS_DIM = ")+to_string(MAX_SYS_DIM)+string(", need ")+to_string(ngbla::Height<TM>()));
-	  return nullptr;
-	}
-      else
-        // return make_shared<BlockJacobiPrecond<TM,TV_ROW,TV_COL>> (*this, blocks, parallel);
-
-        return make_shared<BlockJacobiPrecond<TM,TV_ROW,TV_COL>>
-          ( dynamic_pointer_cast<const SparseMatrix>
-            (this->shared_from_this()),
-            blocks, parallel);
-    }
+                                shared_ptr<BitArray> freedofs = NULL) const override;
 
     virtual shared_ptr<BaseMatrix> InverseMatrix (shared_ptr<BitArray> subset = nullptr) const override;
     virtual shared_ptr<BaseMatrix> InverseMatrix (shared_ptr<const Array<int>> clusters) const override;
@@ -793,24 +772,12 @@ namespace ngla
       this->AddElementMatrixSymmetric (dnums1, elmat, use_atomic);
     }
     
-    virtual shared_ptr<BaseJacobiPrecond> CreateJacobiPrecond (shared_ptr<BitArray> inner) const override
-    { 
-      return make_shared<JacobiPrecondSymmetric<TM,TV>> (*this, inner);
-    }
-
+    virtual shared_ptr<BaseJacobiPrecond> CreateJacobiPrecond (shared_ptr<BitArray> inner) const override;
     virtual shared_ptr<BaseBlockJacobiPrecond>
       CreateBlockJacobiPrecond (shared_ptr<Table<int>> blocks,
                                 const BaseVector * constraint = 0,
                                 bool parallel  = 1,
-                                shared_ptr<BitArray> freedofs = NULL) const override
-    { 
-      // return make_shared<BlockJacobiPrecondSymmetric<TM,TV>> (*this, blocks);
-      return make_shared<BlockJacobiPrecondSymmetric<TM,TV>>
-        ( dynamic_pointer_cast<const SparseMatrixSymmetric>
-          (this->shared_from_this()),
-          blocks);
-    }
-
+                                shared_ptr<BitArray> freedofs = NULL) const override;
 
     virtual shared_ptr<BaseSparseMatrix> Restrict (const SparseMatrixTM<double> & prol,
 					 shared_ptr<BaseSparseMatrix> cmat = nullptr) const override;

netgen/include/sparsematrix_dyn.hpp

@@ -8,6 +8,8 @@
 /**************************************************************************/
 
 
+#include "sparsematrix.hpp"
+
 namespace ngla
 {
 

netgen/include/sparsematrix_impl.hpp

@@ -155,6 +155,44 @@ namespace ngla
     : SparseMatrixTM<TM> (std::move(agraph))
   { ; }
  
+
+
+  template <class TM, class TV_ROW, class TV_COL>  
+  shared_ptr<BaseJacobiPrecond> SparseMatrix<TM,TV_ROW,TV_COL> :: 
+  CreateJacobiPrecond (shared_ptr<BitArray> inner) const
+  {
+    // if constexpr(mat_traits<TM>::HEIGHT != mat_traits<TM>::WIDTH) return nullptr;
+    if constexpr(ngbla::Height<TM>() != ngbla::Width<TM>()) return nullptr;
+    else if constexpr(ngbla::Height<TM>() > MAX_SYS_DIM) {
+      throw Exception(string("MAX_SYS_DIM = ")+to_string(MAX_SYS_DIM)+string(", need ")+to_string(mat_traits<TM>::HEIGHT));
+      return nullptr;
+    }
+    else return make_shared<JacobiPrecond<TM,TV_ROW,TV_COL>> (*this, inner);
+  }
+  
+  template <class TM, class TV_ROW, class TV_COL>    
+  shared_ptr<BaseBlockJacobiPrecond> SparseMatrix<TM,TV_ROW,TV_COL> :: 
+  CreateBlockJacobiPrecond (shared_ptr<Table<int>> blocks,
+                            const BaseVector * constraint,
+                            bool parallel,
+                            shared_ptr<BitArray> freedofs) const
+  { 
+    // if constexpr(mat_traits<TM>::HEIGHT != mat_traits<TM>::WIDTH) return nullptr;
+    if constexpr(ngbla::Height<TM>() != ngbla::Width<TM>()) return nullptr;
+    else if constexpr(ngbla::Height<TM>() > MAX_SYS_DIM) {
+      throw Exception(string("MAX_SYS_DIM = ")+to_string(MAX_SYS_DIM)+string(", need ")+to_string(ngbla::Height<TM>()));
+      return nullptr;
+    }
+    else
+      // return make_shared<BlockJacobiPrecond<TM,TV_ROW,TV_COL>> (*this, blocks, parallel);
+      
+      return make_shared<BlockJacobiPrecond<TM,TV_ROW,TV_COL>>
+        ( dynamic_pointer_cast<const SparseMatrix>
+          (this->shared_from_this()),
+          blocks, parallel);
+  }
+  
+
   
   template <class TM, class TV_ROW, class TV_COL>
   void SparseMatrix<TM,TV_ROW,TV_COL> ::
@@ -602,7 +640,7 @@ namespace ngla
   
   template <class TM>
   shared_ptr<BaseSparseMatrix> SparseMatrixTM<TM> ::
-  CreateTransposeTM (const function<shared_ptr<SparseMatrixTM<decltype(Trans(TM()))>>(const Array<int>&,int)> & creator) const
+  CreateTransposeTM (const function<shared_ptr<SparseMatrixTM<decltype(ngbla::Trans(TM()))>>(const Array<int>&,int)> & creator) const
   {
     Array<int> cnt(this->Width());
     cnt = 0;
@@ -750,7 +788,34 @@ namespace ngla
   {
     ; 
   }
+  
+
+  template <class TM, class TV>
+  shared_ptr<BaseJacobiPrecond>
+  SparseMatrixSymmetric<TM,TV> :: CreateJacobiPrecond (shared_ptr<BitArray> inner) const 
+  { 
+    return make_shared<JacobiPrecondSymmetric<TM,TV>> (*this, inner);
+  }
+  
 
+  template <class TM, class TV>  
+  shared_ptr<BaseBlockJacobiPrecond>
+  SparseMatrixSymmetric<TM,TV> :: CreateBlockJacobiPrecond (shared_ptr<Table<int>> blocks,
+                                                            const BaseVector * constraint,
+                                                            bool parallel,
+                                                            shared_ptr<BitArray> freedofs) const
+  { 
+    // return make_shared<BlockJacobiPrecondSymmetric<TM,TV>> (*this, blocks);
+    return make_shared<BlockJacobiPrecondSymmetric<TM,TV>>
+      ( dynamic_pointer_cast<const SparseMatrixSymmetric>
+        (this->shared_from_this()),
+        blocks);
+  }
+  
+
+
+
+  
   template <class TM, class TV>
   void SparseMatrixSymmetric<TM,TV> :: 
   MultAdd (double s, const BaseVector & x, BaseVector & y) const