ngsolve 6.2.2501.post21.dev1__cp313-cp313-macosx_10_15_universal2.whl → 6.2.2501.post34.dev1__cp313-cp313-macosx_10_15_universal2.whl

netgen/include/diffop_impl.hpp

@@ -1,326 +0,0 @@
-#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 & mip,
-                            SliceMatrix<double> trans,
-                            LocalHeap & lh) const
-  {
-    DIFFOP::CalcTransformationMatrix(mip, trans, lh);    
-  }
-  
-#endif  
-}
-
-
-#endif

netgen/include/discontinuous.hpp

@@ -1,84 +0,0 @@
-#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_