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

netgen/include/diffop_impl.hpp

@@ -0,0 +1,328 @@
+#ifndef FILE_DIFFOP_IMPL
+#define FILE_DIFFOP_IMPL
+
+/*********************************************************************/
+/* File:   diffop.hpp                                                */
+/* Author: Joachim Schoeberl                                         */
+/* Date:   24. Nov. 2009                                             */
+/*********************************************************************/
+
+
+#include "diffop.hpp"
+
+namespace ngfem
+{
+
+  /*
+  template <typename DIFFOP>
+  T_DifferentialOperator<DIFFOP> :: T_DifferentialOperator()
+    : DifferentialOperator(DIFFOP::DIM_DMAT, 1, VorB(int(DIM_SPACE)-int(DIM_ELEMENT)), DIFFOP::DIFFORDER)
+  {
+    static ngcore::RegisterClassForArchive<ngfem::T_DifferentialOperator<DIFFOP>, DifferentialOperator> reg;
+    Array<int> hdims;
+    hdims = DIFFOP::GetDimensions();
+    SetDimensions ( hdims );
+  }
+  */
+  
+  template <typename DIFFOP>
+  void T_DifferentialOperator<DIFFOP> ::
+  CalcMatrix (const FiniteElement & bfel,
+              const BaseMappedIntegrationPoint & bmip,
+              BareSliceMatrix<double,ColMajor> mat, 
+              LocalHeap & lh) const
+  {
+    const MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE> & mip =
+      static_cast<const MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE>&> (bmip);
+    auto mat2 = mat.Rows<DIM_DMAT>().Cols(DIM*bfel.GetNDof());
+    DIFFOP::GenerateMatrix (bfel, mip, mat2, lh);
+  }
+
+
+  template <bool ENABLE_PML>
+  class GenerateMatrix_PMLWrapper
+  {
+  public:
+    template <typename DIFFOP, typename FEL, typename MIP, typename MAT>
+    static void GenerateMatrix (const FEL & fel, const MIP & mip,
+                                MAT & mat, LocalHeap & lh)
+    {
+      DIFFOP::GenerateMatrix (fel, mip, mat, lh);        
+    }
+
+    template <typename DIFFOP, typename FEL, typename MIR, typename TVX, typename TVY>
+    static void ApplyIR (const FEL & fel, const MIR & mir,
+                         const TVX & x, TVY & flux,
+                         LocalHeap & lh)
+    {
+      DIFFOP::ApplyIR (fel, mir, x, flux, lh);
+    }
+  };
+
+  template <> class GenerateMatrix_PMLWrapper<false>
+  {
+  public:
+    template <typename DIFFOP, typename FEL, typename MIP, typename MAT>
+    static void GenerateMatrix (const FEL & fel, const MIP & mip,
+                                MAT & mat, LocalHeap & lh)
+    {
+      Exception::Throw("PML not supported for diffop ", DIFFOP::Name(),
+                       "\nit might be enough to set SUPPORT_PML to true in the diffop");
+    }
+    template <typename DIFFOP, typename FEL, typename MIR, typename TVX, typename TVY>
+    static void ApplyIR (const FEL & fel, const MIR & mir,
+                         const TVX & x, TVY & y,
+                         LocalHeap & lh)
+    {
+      Exception::Throw("PML not supported for diffop ", DIFFOP::Name(), 
+                       " ApplyIR\nit might be enough to set SUPPORT_PML to true in the diffop");
+    }
+  };
+  
+    
+  
+  
+  template <typename DIFFOP>
+  void T_DifferentialOperator<DIFFOP> ::
+  CalcMatrix (const FiniteElement & bfel,
+              const BaseMappedIntegrationPoint & bmip,
+              BareSliceMatrix<Complex,ColMajor> mat, 
+              LocalHeap & lh) const
+  {
+    if (bmip.IsComplex())
+      {
+        const MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE,Complex> & mip =
+          static_cast<const MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE,Complex>&> (bmip);
+        // DIFFOP::GenerateMatrix (bfel, mip, mat, lh);
+        GenerateMatrix_PMLWrapper<DIFFOP::SUPPORT_PML>::template GenerateMatrix<DIFFOP> (bfel, mip, mat, lh);
+      }
+    else
+      {
+        const MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE> & mip =
+          static_cast<const MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE>&> (bmip);
+        GenerateMatrix_PMLWrapper<DIFFOP::SUPPORT_PML>::template GenerateMatrix<DIFFOP> (bfel, mip, mat, lh);        
+        // DIFFOP::GenerateMatrix (bfel, mip, mat, lh);        
+        // throw Exception ("cannot do complex matrix for real mip");
+        // ThrowException ("cannot do complex matrix for real mip");
+      }
+  }
+
+  template <typename DIFFOP>
+  void T_DifferentialOperator<DIFFOP> ::
+  CalcMatrix (const FiniteElement & bfel,
+              const BaseMappedIntegrationRule & bmir,
+              BareSliceMatrix<double,ColMajor> mat, 
+              LocalHeap & lh) const
+  {
+    const MappedIntegrationRule<DIM_ELEMENT,DIM_SPACE> & mir =
+      static_cast<const MappedIntegrationRule<DIM_ELEMENT,DIM_SPACE>&> (bmir);
+    DIFFOP::GenerateMatrixIR (bfel, mir, mat, lh);
+  }
+
+  template <typename DIFFOP>
+  void T_DifferentialOperator<DIFFOP> ::
+  CalcMatrix (const FiniteElement & bfel,
+              const SIMD_BaseMappedIntegrationRule & bmir,
+              BareSliceMatrix<SIMD<double>> mat) const
+  {
+    DIFFOP::GenerateMatrixSIMDIR (bfel, bmir, mat);
+  }
+
+
+  template <typename DIFFOP>
+  void T_DifferentialOperator<DIFFOP> ::
+  Apply (const FiniteElement & bfel,
+         const BaseMappedIntegrationPoint & bmip,
+         BareSliceVector<double> x, 
+         FlatVector<double> flux,
+         LocalHeap & lh) const
+  {
+    const MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE> & mip =
+      static_cast<const MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE>&> (bmip);
+    DIFFOP::Apply (bfel, mip, x, flux, lh);
+  }
+  
+#ifndef FASTCOMPILE
+  template <typename DIFFOP>
+  void T_DifferentialOperator<DIFFOP> ::
+  Apply (const FiniteElement & bfel,
+         const BaseMappedIntegrationRule & bmir,
+         BareSliceVector<double> x, 
+         BareSliceMatrix<double> flux,
+         LocalHeap & lh) const
+  {
+    const MappedIntegrationRule<DIM_ELEMENT,DIM_SPACE> & mir =
+      static_cast<const MappedIntegrationRule<DIM_ELEMENT,DIM_SPACE>&> (bmir);
+    auto fluxsize = flux.AddSize(mir.Size(), DIFFOP::DIM_DMAT);
+    DIFFOP::ApplyIR (bfel, mir, x, fluxsize, lh);
+  }
+
+  template <typename DIFFOP>
+  void T_DifferentialOperator<DIFFOP> ::
+  Apply (const FiniteElement & bfel,
+         const BaseMappedIntegrationPoint & bmip,
+         BareSliceVector<Complex> x, 
+         FlatVector<Complex> flux,
+         LocalHeap & lh) const
+  {
+    const MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE> & mip =
+      static_cast<const MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE>&> (bmip);
+    DIFFOP::Apply (bfel, mip, x, flux, lh);
+  }
+  
+  template <typename DIFFOP>
+  void T_DifferentialOperator<DIFFOP> ::
+  Apply (const FiniteElement & bfel,
+         const BaseMappedIntegrationRule & bmir,
+         BareSliceVector<Complex> x, 
+         BareSliceMatrix<Complex> flux,
+         LocalHeap & lh) const
+  {
+    auto fluxsize = flux.AddSize(bmir.Size(), DIFFOP::DIM_DMAT);
+    if (bmir.IsComplex())
+      {
+        const MappedIntegrationRule<DIM_ELEMENT,DIM_SPACE,Complex> & mir =
+          static_cast<const MappedIntegrationRule<DIM_ELEMENT,DIM_SPACE,Complex>&> (bmir);
+
+        GenerateMatrix_PMLWrapper<DIFFOP::SUPPORT_PML>::template ApplyIR<DIFFOP> (bfel, mir, x, fluxsize, lh);
+        // DIFFOP::ApplyIR (bfel, mir, x, flux, lh);
+      }
+    else
+      {
+        const MappedIntegrationRule<DIM_ELEMENT,DIM_SPACE> & mir =
+          static_cast<const MappedIntegrationRule<DIM_ELEMENT,DIM_SPACE>&> (bmir);
+        DIFFOP::ApplyIR (bfel, mir, x, fluxsize, lh);
+      }
+    
+
+  }
+
+
+  template <typename DIFFOP>
+  void T_DifferentialOperator<DIFFOP> ::
+  Apply (const FiniteElement & bfel,
+         const SIMD_BaseMappedIntegrationRule & bmir,
+         BareSliceVector<double> x, 
+         BareSliceMatrix<SIMD<double>> flux) const
+  {
+    DIFFOP::ApplySIMDIR (bfel, bmir, x, flux);
+  }
+
+  template <typename DIFFOP>
+  void T_DifferentialOperator<DIFFOP> ::
+  Apply (const FiniteElement & bfel,
+         const SIMD_BaseMappedIntegrationRule & bmir,
+         BareSliceVector<Complex> x, 
+         BareSliceMatrix<SIMD<Complex>> flux) const
+  {
+    DIFFOP::ApplySIMDIR (bfel, bmir, x, flux);
+  }
+
+
+  
+  template <typename DIFFOP>
+  void T_DifferentialOperator<DIFFOP> ::
+  ApplyTrans (const FiniteElement & bfel,
+              const BaseMappedIntegrationPoint & bmip,
+              FlatVector<double> flux,
+              BareSliceVector<double> x, 
+              LocalHeap & lh) const 
+  {
+    const MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE> & mip =
+      static_cast<const MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE>&> (bmip);
+    DIFFOP::ApplyTrans (bfel, mip, flux, x, lh);
+  }    
+
+  template <typename DIFFOP>
+  void T_DifferentialOperator<DIFFOP> ::
+  ApplyTrans (const FiniteElement & bfel,
+              const BaseMappedIntegrationPoint & bmip,
+              FlatVector<Complex> flux,
+              BareSliceVector<Complex> x, 
+              LocalHeap & lh) const 
+  {
+    const MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE> & mip =
+      static_cast<const MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE>&> (bmip);
+    DIFFOP::ApplyTrans (bfel, mip, flux, x, lh);
+  }    
+
+  template <typename DIFFOP>
+  void T_DifferentialOperator<DIFFOP> ::
+  ApplyTrans (const FiniteElement & bfel,
+              const BaseMappedIntegrationRule & bmir,
+              FlatMatrix<double> flux,
+              BareSliceVector<double> x, 
+              LocalHeap & lh) const 
+  {
+    const MappedIntegrationRule<DIM_ELEMENT,DIM_SPACE> & mir =
+      static_cast<const MappedIntegrationRule<DIM_ELEMENT,DIM_SPACE>&> (bmir);
+    DIFFOP::ApplyTransIR (bfel, mir, flux, x, lh);
+  }    
+
+  template <typename DIFFOP>
+  void T_DifferentialOperator<DIFFOP> ::
+  ApplyTrans (const FiniteElement & bfel,
+              const BaseMappedIntegrationRule & bmir,
+              FlatMatrix<Complex> flux,
+              BareSliceVector<Complex> x, 
+              LocalHeap & lh) const 
+  {
+    const MappedIntegrationRule<DIM_ELEMENT,DIM_SPACE> & mir =
+      static_cast<const MappedIntegrationRule<DIM_ELEMENT,DIM_SPACE>&> (bmir);
+    DIFFOP::ApplyTransIR (bfel, mir, flux, x, lh);
+  }    
+
+
+  template <typename DIFFOP>
+  void T_DifferentialOperator<DIFFOP> ::
+  AddTrans (const FiniteElement & bfel,
+            const SIMD_BaseMappedIntegrationRule & bmir,
+            BareSliceMatrix<SIMD<double>> flux,
+            BareSliceVector<double> x) const
+  {
+    DIFFOP::AddTransSIMDIR (bfel, bmir, flux, x);
+  }
+  
+  template <typename DIFFOP>
+  void T_DifferentialOperator<DIFFOP> ::
+  AddTrans (const FiniteElement & bfel,
+            const SIMD_BaseMappedIntegrationRule & bmir,
+            BareSliceMatrix<SIMD<Complex>> flux,
+            BareSliceVector<Complex> x) const
+  {
+    DIFFOP::AddTransSIMDIR (bfel, bmir, flux, x);
+  }
+
+  template <typename DIFFOP>
+  int T_DifferentialOperator<DIFFOP> :: DimRef() const
+  {
+    return DIFFOP::DimRef();
+  }
+
+  
+  template <typename DIFFOP>
+  void T_DifferentialOperator<DIFFOP> ::
+  CalcMatrix (const FiniteElement & fel,
+              const IntegrationPoint & ip,
+              BareSliceMatrix<double,ColMajor> mat,
+              LocalHeap & lh) const
+  {
+    DIFFOP::GenerateMatrixRef(fel, ip, mat, lh);
+  }
+  
+  template <typename DIFFOP>
+  void T_DifferentialOperator<DIFFOP> ::
+  CalcTransformationMatrix (const BaseMappedIntegrationPoint & bmip,
+                            SliceMatrix<double> trans,
+                            LocalHeap & lh) const
+  {
+    const MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE> & mip =
+      static_cast<const MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE>&> (bmip);
+    DIFFOP::CalcTransformationMatrix(mip, trans, lh);    
+  }
+  
+#endif  
+}
+
+
+#endif

netgen/include/diffopwithfactor.hpp

@@ -0,0 +1,123 @@
+#ifndef DIFFOPWITHFACTOR_HPP
+#define DIFFOPWITHFACTOR_HPP
+
+
+
+namespace ngsbem
+{
+  using namespace ngfem;
+
+  class DifferentialOperatorWithFactor : public DifferentialOperator
+  {
+    shared_ptr<DifferentialOperator> diffop;
+    shared_ptr<CoefficientFunction> factor;
+
+  public:
+    DifferentialOperatorWithFactor (shared_ptr<DifferentialOperator> adiffop,
+                                    shared_ptr<CoefficientFunction> afactor)
+      : DifferentialOperator(afactor->Dimensions()[0], 1, adiffop->VB(), adiffop->DiffOrder()),
+        diffop(adiffop), factor(afactor)
+    {
+      ;
+    }
+
+    int DimRef() const override { return diffop->DimRef(); }
+
+    virtual IntRange UsedDofs(const FiniteElement & fel) const override { return diffop->UsedDofs(fel); }
+
+    auto BaseDiffOp() const { return diffop; }
+
+    void CalcMatrix (const FiniteElement & fel,
+                     const BaseMappedIntegrationPoint & mip,
+                     BareSliceMatrix<double,ColMajor> mat, 
+                     LocalHeap & lh) const override
+    {
+      FlatMatrix<double,ColMajor> hmat(diffop->Dim(), fel.GetNDof(), lh);
+      diffop -> CalcMatrix (fel, mip, hmat, lh);
+
+      auto dims = factor->Dimensions();      
+      FlatMatrix<double> factorx(dims[0], dims[1], lh);
+      factor->Evaluate (mip, factorx.AsVector());
+
+      IntRange used = diffop->UsedDofs(fel);
+      mat.Cols(used) = factorx * hmat.Cols(used);
+    }
+    
+    void CalcMatrix (const FiniteElement & fel,
+                     const SIMD_BaseMappedIntegrationRule & mir,
+                     BareSliceMatrix<SIMD<double>> mat) const override
+    {
+      // *testout << "CalcMatrix SIMD" << endl;      
+      Matrix<SIMD<double>> hmat (fel.GetNDof()*diffop->Dim(), mir.Size());
+      // hmat = SIMD<double>(0.0);
+      diffop -> CalcMatrix (fel, mir, hmat);
+
+      Matrix<SIMD<double>> fac(factor->Dimension(), mir.Size());
+      factor -> Evaluate (mir, fac);
+
+      auto dims = factor -> Dimensions();
+
+      mat.Rows(fel.GetNDof()*dims[1]).Cols(mir.Size()) = SIMD<double>(0.0);
+      
+      for (size_t i = 0; i < mir.Size(); i++)
+        for (size_t j = 0; j < dims[0]; j++)
+          for (size_t k = 0; k < dims[1]; k++)
+            mat.Col(i).Slice(j,dims[0]) += fac(j*dims[1]+k, i) * hmat.Col(i).Slice(k, dims[1]);
+    }
+    
+
+    void CalcMatrix (const FiniteElement & fel,
+                     const IntegrationPoint & ip,
+                     BareSliceMatrix<double,ColMajor> mat,
+                     LocalHeap & lh) const override
+    {
+      diffop -> CalcMatrix(fel, ip, mat, lh);
+      /*
+      *testout << "calcmatrix mip" << endl
+               << mat.Rows(Dim()).Cols(fel.GetNDof()) << endl;
+      */
+    }
+
+    void CalcTransformationMatrix (const BaseMappedIntegrationPoint & mip,
+                                   SliceMatrix<double> trans,
+                                   LocalHeap & lh) const override
+    {
+      HeapReset hr(lh);
+      auto dims = factor->Dimensions();
+      
+      FlatMatrix<double> factorx(dims[0], dims[1], lh);
+      factor->Evaluate (mip, factorx.AsVector());
+
+      FlatMatrix<double> basetrans(diffop->Dim(), diffop->DimRef(), lh);
+      diffop -> CalcTransformationMatrix(mip, basetrans, lh);
+
+      trans = factorx * basetrans;
+      // *testout << "trans = " << trans << endl;
+    }
+
+
+    void Apply (const FiniteElement & fel,
+                const SIMD_BaseMappedIntegrationRule & mir,
+                BareSliceVector<double> x, 
+                BareSliceMatrix<SIMD<double>> flux) const override
+    {
+      auto dims = factor->Dimensions();
+
+      Matrix<SIMD<double>> tmpflux(dims[1], mir.Size());
+      Matrix<SIMD<double>> factorx(dims[0]*dims[1], mir.Size());
+      
+      diffop -> Apply (fel, mir, x, tmpflux);
+      factor -> Evaluate (mir, factorx);
+      flux.Rows(0, dims[0]).Cols(0, mir.Size()) = SIMD<double>(0.0);
+      for (int i = 0; i < dims[0]; i++)
+        for (int j = 0; j < dims[1]; j++)
+          flux.Row(i).Range(mir.Size()) += pw_mult(factorx.Row(i*dims[1]+j), tmpflux.Row(j));
+    }
+
+    
+  };
+
+
+}
+
+#endif

netgen/include/discontinuous.hpp

@@ -0,0 +1,84 @@
+#ifndef FILE_DISCONTINUOUS_
+#define FILE_DISCONTINUOUS_
+
+/*********************************************************************/
+/* File:   discontinuous.hpp                                         */
+/* Author: Joachim Schoeberl                                         */
+/* Date:   Jun 2019                                                  */
+/*********************************************************************/
+
+#include "fespace.hpp"
+
+namespace ngcomp
+{
+
+ // A discontinuous wrapper class for fespaces 
+
+  class DiscontinuousFESpace : public FESpace
+  {
+  protected:
+    Array<DofId> first_element_dof; 
+    shared_ptr<FESpace> space;
+    VorB vb;
+    
+  public:
+    DiscontinuousFESpace (shared_ptr<FESpace> space, const Flags & flags);
+    
+    virtual ~DiscontinuousFESpace () { ; }
+    void Update () override;
+    
+    void FinalizeUpdate() override
+    {
+      space->FinalizeUpdate();
+      FESpace::FinalizeUpdate();
+    }
+
+    virtual FlatArray<VorB> GetDualShapeNodes (VorB vb) const override
+    {
+      return space->GetDualShapeNodes(vb);
+    }
+
+
+    virtual string GetClassName() const override { return "Discontinuous" + 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); }    
+  };
+
+}
+
+
+#endif // FILE_DISCONTINUOUS_