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

netgen/include/pardisoinverse.hpp

@@ -0,0 +1,200 @@
+#ifndef FILE_PARDISOINVERSE
+#define FILE_PARDISOINVERSE
+
+/* *************************************************************************/
+/* File:   pardisoinverse.hpp                                              */
+/* Author: Florian Bachinger                                               */
+/* Date:   Feb. 04                                                         */
+/* *************************************************************************/
+
+/*
+  interface to the PARDISO - package
+*/
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+#include "sparsecholesky.hpp"  // for SparseFactorization
+
+namespace ngla
+{
+  using ngbla::integer;
+  extern bool is_pardiso_available;
+
+
+  /*
+  template<class TM, 
+	   class TV_ROW = typename mat_traits<TM>::TV_ROW, 
+	   class TV_COL = typename mat_traits<TM>::TV_COL>
+  class PardisoInverse : public SparseFactorization
+  {
+    integer height;             // matrix size in scalars
+    integer compressed_height;  // matrix size after compression in scalars
+    integer nze, entrysize;
+    bool print;
+
+    integer pt[128];
+    integer hparams[64];
+
+    Array<integer,size_t> rowstart, indices; 
+    Array<typename mat_traits<TM>::TSCAL,size_t> matrix;
+
+    integer matrixtype;
+    bool symmetric, spd;
+
+    void SetMatrixType(); 
+
+    bool compressed;
+    Array<int> compress;
+  
+  public:
+    typedef TV_COL TV;
+    typedef TV_ROW TVX;
+    typedef typename mat_traits<TM>::TSCAL TSCAL;
+
+    ///
+    PardisoInverse (const SparseMatrix<TM,TV_ROW,TV_COL> & a, 
+		    const BitArray * ainner = NULL,
+		    const Array<int> * acluster = NULL,
+		    int symmetric = 0);
+    ///
+
+    template <typename TSUBSET>
+    void GetPardisoMatrix (const SparseMatrix<TM,TV_ROW,TV_COL> & a, TSUBSET subset);
+
+    virtual ~PardisoInverse ();
+    ///
+    int VHeight() const { return height/entrysize; }
+    ///
+    int VWidth() const { return height/entrysize; }
+    ///
+    virtual void Mult (const BaseVector & x, BaseVector & y) const;
+
+
+    ///
+    virtual ostream & Print (ostream & ost) const;
+
+    virtual void MemoryUsage (Array<MemoryUsageStruct*> & mu) const
+    {
+      mu.Append (new MemoryUsageStruct ("SparseChol", nze*sizeof(TM), 1));
+    }
+    virtual BaseVector * CreateVector () const
+    {
+      return new VVector<TV> (height/entrysize);
+    }
+  };
+  */
+
+
+
+
+
+
+
+
+
+  template<class TM>
+  class PardisoInverseTM : public SparseFactorization
+  {
+  protected:
+    integer height;             // matrix size in scalars
+    integer compressed_height;  // matrix size after compression in scalars
+    integer nze, entrysize;
+    bool print;
+
+    integer pt[128];
+    integer hparams[64];
+
+    Array<integer> rowstart, indices; 
+    Array<typename mat_traits<TM>::TSCAL> matrix;
+
+    integer matrixtype;
+    bool symmetric, spd;
+
+    void SetMatrixType(); 
+
+    bool compressed;
+    Array<int> compress;
+    size_t memory_allocated_in_pardiso_lib = 0;
+  
+  public:
+    typedef typename mat_traits<TM>::TSCAL TSCAL;
+
+    ///
+    PardisoInverseTM (shared_ptr<const SparseMatrixTM<TM>> a,
+		      shared_ptr<BitArray> ainner = nullptr,
+		      shared_ptr<const Array<int>> acluster = nullptr,
+		      int symmetric = 0);
+    ///
+
+    template <typename TSUBSET>
+    void GetPardisoMatrix (const SparseMatrixTM<TM> & a, TSUBSET subset);
+
+    virtual ~PardisoInverseTM ();
+    ///
+    int VHeight() const { return height/entrysize; }
+    ///
+    int VWidth() const { return height/entrysize; }
+    ///
+    virtual ostream & Print (ostream & ost) const;
+
+    virtual Array<MemoryUsage> GetMemoryUsage () const
+    {
+      return { MemoryUsage ("Pardiso", nze*sizeof(TM), 1) };
+    }
+  };
+
+
+  template<class TM, 
+	   class TV_ROW = typename mat_traits<TM>::TV_ROW, 
+	   class TV_COL = typename mat_traits<TM>::TV_COL>
+  class PardisoInverse : public PardisoInverseTM<TM>
+  {
+    using PardisoInverseTM<TM>::height;
+    using PardisoInverseTM<TM>::compressed_height;
+    using PardisoInverseTM<TM>::entrysize;
+    using PardisoInverseTM<TM>::pt;
+    using PardisoInverseTM<TM>::hparams;
+    using PardisoInverseTM<TM>::matrixtype;
+    using PardisoInverseTM<TM>::rowstart;
+    using PardisoInverseTM<TM>::indices;
+    using PardisoInverseTM<TM>::matrix;
+    using PardisoInverseTM<TM>::compressed;
+    using PardisoInverseTM<TM>::compress;
+
+  public:
+    typedef TV_COL TV;
+    typedef TV_ROW TVX;
+    typedef typename mat_traits<TM>::TSCAL TSCAL;
+
+    ///
+    PardisoInverse (shared_ptr<const SparseMatrix<TM,TV_ROW,TV_COL>> a,
+		    shared_ptr<BitArray> ainner = nullptr,
+		    shared_ptr<const Array<int>> acluster = nullptr,
+		    int symmetric = 0)
+      : PardisoInverseTM<TM> (a, ainner, acluster, symmetric) { ; }
+
+    virtual ~PardisoInverse () { ; }
+    ///
+    void Mult (const BaseVector & x, BaseVector & y) const override;
+    void MultTrans (const BaseVector & x, BaseVector & y) const override;
+    ///
+
+    AutoVector CreateRowVector() const override
+    {
+      return make_unique<VVector<TV>> (height/entrysize);
+    }
+    AutoVector CreateColVector () const override
+    {
+      return make_unique<VVector<TV>> (height/entrysize);
+    }
+  };
+
+
+
+
+
+}
+
+#endif

netgen/include/periodic.hpp

@@ -0,0 +1,129 @@
+#ifndef FILE_PERIODIC_
+#define FILE_PERIODIC_
+
+/*********************************************************************/
+/* File:   periodic.hpp                                              */
+/* Author: Christopher Lackner                                       */
+/* Date:   Feb. 2017                                                 */
+/*********************************************************************/
+
+#include <set>
+#include "fespace.hpp"
+
+namespace ngcomp
+{
+
+ // A periodic wrapper class for fespaces 
+
+  class NGS_DLL_HEADER PeriodicFESpace : public FESpace
+  {
+  protected:
+    Array<int> dofmap; // mapping of dofs
+    Array<int> vertex_map; // mapping of vertices
+    shared_ptr<FESpace> space;
+    shared_ptr<Array<int>> used_idnrs;
+    
+  public:
+    PeriodicFESpace (shared_ptr<FESpace> space, const Flags & flags, shared_ptr<Array<int>> aused_idnrs);
+    
+    virtual ~PeriodicFESpace () { ; }
+    void Update() override;
+    void DoArchive (Archive & archive) override;
+    auto GetCArgs () { return std::make_tuple(Shallow(space), GetFlags(), used_idnrs); }
+    
+    void FinalizeUpdate() override
+    {
+      space->FinalizeUpdate();
+      FESpace::FinalizeUpdate();
+    }
+
+    ProxyNode MakeProxyFunction (bool testfunction,
+                                 const function<shared_ptr<ProxyFunction>(shared_ptr<ProxyFunction>)> & addblock) const override;
+    
+    shared_ptr<Array<int>> GetUsedIdnrs() const { return used_idnrs; }
+    virtual string GetClassName() const override { return "Periodic" + space->GetClassName(); }
+    shared_ptr<FESpace> GetBaseSpace() const { return space; }
+    
+    virtual FiniteElement & GetFE (ElementId ei, Allocator & alloc) const override;
+
+    virtual size_t GetNDof () const override { return space->GetNDof(); }
+    virtual size_t GetNDofLevel (int level) const override { return space->GetNDofLevel(level); }
+
+    virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
+    virtual void GetDofNrs (NodeId ni, Array<DofId> & dnums) const override;
+
+    virtual SymbolTable<shared_ptr<DifferentialOperator>> GetAdditionalEvaluators () const override
+    { return space->GetAdditionalEvaluators (); }
+
+    [[deprecated("Use GetDofNrs(NODE_TYPE(NT_VERTEX,nr) instead")]]    
+    virtual void GetVertexDofNrs (int vnr,  Array<DofId> & dnums) const override;
+
+    [[deprecated("Use GetDofNrs(NODE_TYPE(NT_EDGE,nr) instead")]]        
+    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
+    { space->GetInnerDofNrs(elnr, dnums); }
+
+    virtual void VTransformMR (ElementId ei,
+			       SliceMatrix<double> mat, TRANSFORM_TYPE tt) const override
+    { space-> VTransformMR(ei, mat, tt); }
+    virtual void VTransformMC (ElementId ei,
+                               SliceMatrix<Complex> mat, TRANSFORM_TYPE tt) const override
+    { space->VTransformMC (ei, mat, tt); }
+    virtual void VTransformVR (ElementId ei,
+                               SliceVector<double> vec, TRANSFORM_TYPE tt) const override
+    { space->VTransformVR(ei, vec, tt); }
+    virtual void VTransformVC (ElementId ei, 
+                               SliceVector<Complex> vec, TRANSFORM_TYPE tt) const override
+    { space->VTransformVC(ei, vec, tt); }    
+
+    auto & GetVertexMap() const { return vertex_map; }
+    auto & GetDofMap() const { return dofmap; }    
+    FlatArray<VorB> GetDualShapeNodes (VorB vb) const override
+    {
+      return space->GetDualShapeNodes(vb);
+    }
+  protected:
+    // overload in quasiperiodic space
+    virtual void DofMapped(size_t from, size_t to, size_t idnr) { ; }
+  };
+
+  template<typename TSCAL>
+  class QuasiPeriodicFESpace : public PeriodicFESpace
+  {
+    shared_ptr<Array<TSCAL>> factors;
+    Array<TSCAL> dof_factors;
+    Array<set<size_t>> master_dofs;
+
+  public:
+    QuasiPeriodicFESpace (shared_ptr<FESpace> fespace, const Flags & flag, shared_ptr<Array<int>> aused_idnrs, shared_ptr<Array<TSCAL>> afactors);
+
+    void Update() override;
+    void DoArchive (Archive & archive) override {
+      PeriodicFESpace::DoArchive(archive);
+      archive & factors & dof_factors & master_dofs;
+    }
+    auto GetCArgs () {
+      return std::make_tuple(Shallow(GetBaseSpace()), GetFlags(), used_idnrs, factors);
+    }
+
+    shared_ptr<Array<TSCAL>> GetFactors() const { return factors; }
+
+    virtual void VTransformMR (ElementId ei, SliceMatrix<double> mat, TRANSFORM_TYPE tt) const override;
+    virtual void VTransformMC (ElementId ei, SliceMatrix<Complex> mat, TRANSFORM_TYPE tt) const override;
+    virtual void VTransformVR (ElementId ei, SliceVector<double> vec, TRANSFORM_TYPE tt) const override;
+    virtual void VTransformVC (ElementId ei, SliceVector<Complex> vec, TRANSFORM_TYPE tt) const override;
+
+
+    
+  protected:
+    virtual void DofMapped(size_t from, size_t to, size_t idnr) override;
+  };
+  
+
+}
+
+
+#endif // FILE_PERIODIC_

netgen/include/plateaufespace.hpp

@@ -0,0 +1,25 @@
+#ifndef PLATEAUFESPACE_HPP
+#define PLATEAUFESPACE_HPP
+
+/*********************************************************************/
+/* File:   plateaufespace.hpp                                        */
+/* Author: Joachim Schoeberl                                         */
+/* Date:   23 Oct 2023                                               */
+/*********************************************************************/
+
+#include "fespace.hpp"
+
+namespace ngcomp
+{
+
+  class PlateauFESpace : public CompressedFESpace
+  {
+  protected:
+    Array<Region> plateaus;
+  public:
+    PlateauFESpace (shared_ptr<FESpace> afes, Array<Region> aplateaus);
+    void Update() override;
+  };
+  
+}
+#endif

netgen/include/pml.hpp

@@ -0,0 +1,275 @@
+#ifndef FILE_PML
+#define FILE_PML
+
+/*********************************************************************/
+/* File:   pml.hpp                                                   */
+/* Author: Joachim Schoeberl                                         */
+/* Date:   1. Jul. 2004                                              */
+/*********************************************************************/
+
+
+#include "bdbintegrator.hpp"
+
+
+namespace ngfem
+{
+  extern Complex alpha;
+  extern double pml_r;
+  extern double pml_x;
+
+  extern double pml_xmin[3];
+  extern double pml_xmax[3]; 
+
+  /*
+    rect_pml = 0 .... circular pml with radius pml_r
+    rect_pml = 1 .... square pml on square (-pml_x, pml_x)^d
+    rect_pml = 2 .... rectangular pml on (pml_xmin, pml_xmax) x (pml_ymin, pml_ymax) x (pml_zmin, pml_zmax)
+  */
+  extern int rect_pml;
+  
+  // extern bool apply_deriv_alpha;
+
+
+
+  
+
+
+  
+  template <>
+  MappedIntegrationPoint<2,2,Complex> :: 
+  MappedIntegrationPoint (const IntegrationPoint & aip,
+			  const ElementTransformation & aeltrans);
+  // LocalHeap & lh);
+
+  
+  template <>
+  MappedIntegrationPoint<2,2,AutoDiff<1,Complex> > :: 
+  MappedIntegrationPoint (const IntegrationPoint & aip,
+			  const ElementTransformation & aeltrans);
+  // LocalHeap & lh);
+
+
+
+  extern void SetPMLParameters();
+
+
+  template <class DIFFOP, class DMATOP, class FEL = FiniteElement>
+  class PML_BDBIntegrator : public T_BDBIntegrator<DIFFOP,DMATOP,FEL>
+  {
+  public:
+  
+    enum { DIM_SPACE   = DIFFOP::DIM_SPACE };
+    enum { DIM_ELEMENT = DIFFOP::DIM_ELEMENT };
+    enum { DIM_DMAT    = DIFFOP::DIM_DMAT };
+    enum { DIM         = DIFFOP::DIM };
+
+    ///
+
+    PML_BDBIntegrator  (const Array<shared_ptr<CoefficientFunction>> & coeffs)
+      : T_BDBIntegrator<DIFFOP,DMATOP,FEL> (coeffs)
+    { 
+      SetPMLParameters();
+    }
+    
+
+    PML_BDBIntegrator (const DMATOP & admat)
+      : T_BDBIntegrator<DIFFOP,DMATOP,FEL> (admat)
+    { 
+      SetPMLParameters();
+    }
+
+    ///
+    virtual ~PML_BDBIntegrator ()
+    { ; }
+
+
+    ///
+    virtual void
+    CalcElementMatrix (const FiniteElement & bfel, 
+			   const ElementTransformation & eltrans, 
+			   FlatMatrix<double> elmat,
+			   LocalHeap & locheap) const override
+    {
+      throw Exception ("PML cannot generate real matrices");
+    }
+
+    ///
+    virtual void
+    CalcElementMatrix (const FiniteElement & bfel, 
+			   const ElementTransformation & eltrans, 
+			   FlatMatrix<Complex> elmat,
+			   LocalHeap & locheap) const override
+    {
+      try
+	{
+	  const FEL & fel = static_cast<const FEL&> (bfel);
+	  int ndof = fel.GetNDof();
+
+	  elmat = 0;
+	
+	  FlatMatrixFixHeight<DIM_DMAT, Complex> bmat (ndof * DIM, locheap);
+	  FlatMatrixFixHeight<DIM_DMAT, Complex> dbmat (ndof * DIM, locheap);
+
+	  Mat<DIM_DMAT,DIM_DMAT, Complex> dmat;
+
+	  const IntegrationRule & ir = this->GetIntegrationRule (fel);
+
+	  for (int i = 0; i < ir.GetNIP(); i++)
+	    {
+              HeapReset hr (locheap);
+
+	      MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE,Complex> 
+		sip(ir[i], eltrans);
+	      MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE,double> 
+		sip_real(ir[i], eltrans);
+
+	      DIFFOP::GenerateMatrix (fel, sip, bmat, locheap);
+	      this->dmatop.GenerateMatrix (fel, sip_real, dmat, locheap);
+
+	      Complex fac = sip.GetJacobiDet() * sip.IP().Weight();
+
+              dmat *= fac;
+	      dbmat = dmat * bmat;
+	      // elmat += Trans (bmat) * dbmat;
+              /*
+              if (DMATOP::SYMMETRIC)
+                // FastMat<DIM_DMAT> (elmat.Height(), &dbmat(0,0), &bmat(0,0), &elmat(0,0));
+                FastMat<DIM_DMAT> (dbmat, bmat, elmat);
+              else
+              */
+                elmat += Trans (bmat) * dbmat;
+	    } 
+	}
+
+      catch (Exception & e)
+	{
+	  e.Append ("in CalcElementMatrix, type = ");
+	  e.Append (typeid(*this).name());
+	  e.Append ("\n");
+	  throw;
+	}
+      catch (exception & e)
+	{
+	  Exception e2(e.what());
+	  e2.Append ("\nin CalcElementMatrix, type = ");
+	  e2.Append (typeid(*this).name());
+	  e2.Append ("\n");
+	  throw e2;
+	}
+    }
+
+    virtual void
+    CalcFlux (const FiniteElement & fel,
+              const BaseMappedIntegrationPoint & bmip,
+              BareSliceVector<Complex> elx, 
+              FlatVector<Complex> flux,
+              bool applyd,
+              LocalHeap & lh) const override
+    {
+      HeapReset hr(lh);
+      MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE,Complex> 
+        mip(bmip.IP(), bmip.GetTransformation());
+      // cout << "bmip.jacobi = " << static_cast<const MappedIntegrationPoint<3,3>&> (bmip).GetJacobiDet() << endl;
+      // cout << "mip.jacobi = " << mip.GetJacobiDet() << endl;
+
+      DIFFOP::Apply (fel, mip, elx, flux, lh);
+
+      FlatVec<DMATOP::DIM_DMAT,Complex> hflux(&flux(0));
+      if (applyd)
+        this->dmatop.Apply1 (fel, mip, hflux, lh);
+    }
+
+
+    virtual void 
+    ApplyElementMatrix (const FiniteElement & bfel, 
+			const ElementTransformation & eltrans, 
+			const FlatVector<double> elx, 
+			FlatVector<double> ely,
+			void * precomputed,
+			LocalHeap & locheap) const override
+    { ; }
+
+
+    virtual void 
+    ApplyElementMatrix (const FiniteElement & bfel, 
+			const ElementTransformation & eltrans, 
+			const FlatVector<Complex> elx, 
+			FlatVector<Complex> ely,
+			void * precomputed,
+			LocalHeap & locheap) const override
+    {
+      const FEL & fel = static_cast<const FEL&> (bfel);
+      int ndof = fel.GetNDof ();
+    
+      ely = 0;
+
+
+      // if (!apply_deriv_alpha)
+	{
+	  Vec<DIM_DMAT,Complex> hv1;
+	  Vec<DIM_DMAT,Complex> hv2;
+	
+	  FlatVector<Complex> hely (ndof*DIM, locheap);
+	  const IntegrationRule & ir = this->GetIntegrationRule (fel);
+	
+	
+	  for (int i = 0; i < ir.GetNIP(); i++)
+	    {
+	      MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE,Complex> 
+		sip(ir[i], eltrans);
+
+	      MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE,double> 
+		sip_real (ir[i], eltrans);
+	    
+	      DIFFOP::Apply (fel, sip, elx, hv1, locheap);
+	      this -> dmatop.Apply (fel, sip_real, hv1, hv2, locheap);
+	      DIFFOP::ApplyTrans (fel, sip, hv2, hely, locheap);
+	    
+	      Complex fac = sip.GetJacobiDet() * sip.IP().Weight();
+	      ely += fac * hely;
+	    }     
+	}
+        /*
+      else
+	{
+	  Vec<DIM_DMAT, AutoDiff<1,Complex> > hv1;
+	  Vec<DIM_DMAT, AutoDiff<1,Complex> > hv2;
+	
+	  FlatVector<AutoDiff<1,Complex> > hely (ndof*DIM, locheap);
+	  FlatVector<AutoDiff<1,Complex> > helx (ndof*DIM, locheap);
+	  const IntegrationRule & ir = this->GetIntegrationRule (fel);
+	
+	  for (int j = 0; j < helx.Size(); j++)
+	    helx(j) = elx(j);
+	
+	  for (int i = 0; i < ir.GetNIP(); i++)
+	    {
+	      MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE,AutoDiff<1,Complex> >
+		sip(ir[i], eltrans);
+
+	      MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE,double> 
+		sip_real (ir[i], eltrans);
+	    
+	      DIFFOP::Apply (fel, sip, helx, hv1, locheap);
+	      this -> dmatop.Apply (fel, sip_real, hv1, hv2, locheap);
+	      DIFFOP::ApplyTrans (fel, sip, hv2, hely, locheap);
+	    
+	      AutoDiff<1,Complex> fac = sip.GetJacobiDet() * sip.IP().Weight();
+
+	      for (int j = 0; j < hely.Size(); j++)
+		ely(j) += (fac * hely(j)).DValue(0);
+	    }     
+	}
+        */
+    }
+
+
+    ///
+    virtual int GetDimension () const override { return DIM; }
+    ///
+    virtual string Name () const override { return "PML-BDB integrator"; }
+  };
+
+}
+
+#endif