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

netgen/include/symbolicintegrator.hpp

@@ -1,849 +0,0 @@
-#ifndef FILE_SYMBOLICINTEGRATOR
-#define FILE_SYMBOLICINTEGRATOR
-
-/*********************************************************************/
-/* File:   symbolicintegrator.hpp                                    */
-/* Author: Joachim Schoeberl                                         */
-/* Date:   August 2015                                               */
-/*********************************************************************/
-
-namespace ngcomp
-{
-  class FESpace;
-}
-
-
-#include "integrator.hpp"
-#include "coefficient.hpp"
-
-
-namespace ngfem
-{
-
-  class NGS_DLL_HEADER ProxyFunction : public CoefficientFunction
-{
-protected:
-  shared_ptr<ngcomp::FESpace> fes;
-  bool testfunction; // true .. test, false .. trial
-  // bool is_complex;
-  bool is_other;    // neighbour element (DG)
-  shared_ptr<ProxyFunction> primaryproxy;   // derivatives and traces point to it
-  shared_ptr<DifferentialOperator> evaluator;
-  shared_ptr<DifferentialOperator> deriv_evaluator;
-  shared_ptr<DifferentialOperator> trace_evaluator;
-  shared_ptr<DifferentialOperator> trace_deriv_evaluator;
-  shared_ptr<DifferentialOperator> ttrace_evaluator;
-  shared_ptr<DifferentialOperator> ttrace_deriv_evaluator;
-  weak_ptr<ProxyFunction> deriv_proxy;          // weak since we point to the primary proxy
-  shared_ptr<CoefficientFunction> boundary_values; // for DG - apply
-
-  SymbolTable<shared_ptr<DifferentialOperator>> additional_diffops;
-  mutable SymbolTable<weak_ptr<ProxyFunction>> additional_proxies;
-
-  mutable weak_ptr<ProxyFunction> dt;
-  mutable shared_ptr<ProxyFunction> anti_dt;
-  // int dim;
-public:
-  ProxyFunction (shared_ptr<ngcomp::FESpace> afes,
-                                bool atestfunction, bool ais_complex,
-                                shared_ptr<DifferentialOperator> aevaluator, 
-                                shared_ptr<DifferentialOperator> aderiv_evaluator,
-                                shared_ptr<DifferentialOperator> atrace_evaluator,
-                                shared_ptr<DifferentialOperator> atrace_deriv_evaluator,
-                                shared_ptr<DifferentialOperator> attrace_evaluator,
-                                shared_ptr<DifferentialOperator> attrace_deriv_evaluator);
-
-  ProxyFunction (const ProxyFunction &) = default;
-
-  bool IsTrialFunction () const { return !testfunction; }
-  bool IsTestFunction () const { return testfunction; }
-  bool IsOther() const { return is_other; }
-
-  string GetDescription () const override;
-
-  void GenerateCode(Code &code, FlatArray<int> inputs, int index) const override;
-  
-  const shared_ptr<DifferentialOperator> & Evaluator() const { return evaluator; }
-  const shared_ptr<DifferentialOperator> & DerivEvaluator() const { return deriv_evaluator; }
-  const shared_ptr<DifferentialOperator> & TraceEvaluator() const { return trace_evaluator; }
-  const shared_ptr<DifferentialOperator> & TraceDerivEvaluator() const { return trace_deriv_evaluator; }
-  const shared_ptr<DifferentialOperator> & TTraceEvaluator() const { return ttrace_evaluator; }
-  const shared_ptr<DifferentialOperator> & TTraceDerivEvaluator() const { return ttrace_deriv_evaluator; }
-
-  shared_ptr<ProxyFunction> Deriv() const;
-  shared_ptr<ProxyFunction> Trace() const;
-  shared_ptr<CoefficientFunction> Primary() const override
-  { return primaryproxy; }
-  
-  shared_ptr<ProxyFunction> Dt() const;  
-  shared_ptr<ProxyFunction> AntiDt() const;
-  int OrderDt() const;    
-
-  
-  shared_ptr<ProxyFunction> Other(shared_ptr<CoefficientFunction> _boundary_values) const;
-
-  const shared_ptr<CoefficientFunction> & BoundaryValues() const { return boundary_values; } 
-
-  void SetAdditionalEvaluator (string name, shared_ptr<DifferentialOperator> diffop)
-  {
-    additional_diffops.Set (name, diffop);
-  }
-  
-  virtual shared_ptr<DifferentialOperator> GetAdditionalEvaluator (string name) const
-  {
-    if (additional_diffops.Used(name))
-      return additional_diffops[name];
-    return nullptr; // shared_ptr<DifferentialOperator>();
-  }
-
-  SymbolTable<shared_ptr<DifferentialOperator>> GetAdditionalEvaluators () const
-  {
-    return additional_diffops;
-  }
-
-  virtual shared_ptr<ProxyFunction> GetAdditionalProxy (string name) const;
-  
-  shared_ptr<CoefficientFunction> Operator (const string & name) const override;
-  shared_ptr<CoefficientFunction> Operator (shared_ptr<DifferentialOperator> diffop) const override;
-    
-  const shared_ptr<ngcomp::FESpace> & GetFESpace() const { return fes; }
-  void SetFESpace(shared_ptr<ngcomp::FESpace> fespace) { fes = fespace; }
-  
-  virtual double Evaluate (const BaseMappedIntegrationPoint & ip) const override
-  {
-    // Vector<> tmp(Dimension());
-    STACK_ARRAY(double, mem, Dimension());
-    FlatVector<> tmp(Dimension(), &mem[0]);
-    Evaluate (ip, tmp);
-    return tmp(0);
-  }
-
-  virtual void Evaluate (const BaseMappedIntegrationPoint & ip,
-                         FlatVector<> result) const override;
-
-  virtual void Evaluate (const BaseMappedIntegrationPoint & ip,
-                         FlatVector<Complex> result) const override;
-
-  virtual void Evaluate (const BaseMappedIntegrationRule & ir,
-                                        BareSliceMatrix<> result) const override;
-
-  virtual void Evaluate (const BaseMappedIntegrationRule & ir,
-                                        BareSliceMatrix<Complex> result) const override;
-
-  // virtual void Evaluate (const SIMD_BaseMappedIntegrationRule & ir,
-  // AFlatMatrix<double> values) const;
-
-  virtual void Evaluate (const SIMD_BaseMappedIntegrationRule & ir,
-                         BareSliceMatrix<SIMD<double>> values) const override;
-  virtual void Evaluate (const SIMD_BaseMappedIntegrationRule & ir,
-                         BareSliceMatrix<SIMD<Complex>> values) const override;
-
-  /*
-  virtual void Evaluate (const SIMD_BaseMappedIntegrationRule & ir,
-                         FlatArray<AFlatMatrix<double>*> input,
-                         AFlatMatrix<double> values) const override;
-
-  virtual void EvaluateDeriv (const BaseMappedIntegrationRule & mir,
-                              FlatMatrix<> result,
-                              FlatMatrix<> deriv) const override;
-
-  virtual void EvaluateDDeriv (const BaseMappedIntegrationRule & mir,
-                               FlatMatrix<> result,
-                               FlatMatrix<> deriv,
-                               FlatMatrix<> dderiv) const override;
-
-  virtual void EvaluateDeriv (const SIMD_BaseMappedIntegrationRule & ir,
-                              AFlatMatrix<double> values, AFlatMatrix<double> deriv) const override;
-  
-  virtual void EvaluateDDeriv (const SIMD_BaseMappedIntegrationRule & ir,
-                               AFlatMatrix<double> values, AFlatMatrix<double> deriv,
-                               AFlatMatrix<double> dderiv) const override;
-  */
-  virtual void Evaluate (const SIMD_BaseMappedIntegrationRule & ir,
-                         FlatArray<BareSliceMatrix<SIMD<double>>> input,
-                         BareSliceMatrix<SIMD<double>> values) const override
-  {
-    ProxyFunction::Evaluate (ir, values);
-  }
-
-  virtual void Evaluate (const BaseMappedIntegrationRule & ir, 
-                         BareSliceMatrix<AutoDiff<1,double>> values) const override;
-  
-  virtual void Evaluate (const BaseMappedIntegrationRule & ir, 
-                         BareSliceMatrix<AutoDiffDiff<1,double>> values) const override;
-  
-  virtual void Evaluate (const SIMD_BaseMappedIntegrationRule & ir, 
-                         BareSliceMatrix<AutoDiff<1,SIMD<double>>> values) const override;
-
-  virtual void Evaluate (const SIMD_BaseMappedIntegrationRule & ir,
-                         FlatArray<BareSliceMatrix<AutoDiff<1,SIMD<double>>>> input,
-                         BareSliceMatrix<AutoDiff<1,SIMD<double>>> values) const override
-  {
-    ProxyFunction::Evaluate (ir, values);
-  }
-  
-  virtual void Evaluate (const SIMD_BaseMappedIntegrationRule & ir, 
-                         BareSliceMatrix<AutoDiffDiff<1,SIMD<double>>> values) const override;
-
-  virtual void Evaluate (const SIMD_BaseMappedIntegrationRule & ir,
-                         FlatArray<BareSliceMatrix<AutoDiffDiff<1,SIMD<double>>>> input,
-                         BareSliceMatrix<AutoDiffDiff<1,SIMD<double>>> values) const override
-  {
-    ProxyFunction::Evaluate (ir, values);
-  }
-  
-  /*
-  virtual void EvaluateDeriv (const SIMD_BaseMappedIntegrationRule & ir,
-                              FlatArray<AFlatMatrix<>*> input,
-                              FlatArray<AFlatMatrix<>*> dinput,
-                              AFlatMatrix<> result,
-                              AFlatMatrix<> deriv) const override
-  {
-    EvaluateDeriv (ir, result, deriv);
-  }
-  
-  virtual void EvaluateDDeriv (const SIMD_BaseMappedIntegrationRule & ir,
-                               FlatArray<AFlatMatrix<>*> input,
-                               FlatArray<AFlatMatrix<>*> dinput,
-                               FlatArray<AFlatMatrix<>*> ddinput,
-                               AFlatMatrix<> result,
-                               AFlatMatrix<> deriv,
-                               AFlatMatrix<> dderiv) const override
-  {
-    EvaluateDDeriv (ir, result, deriv, dderiv);
-  }
-  */
-  
-  // virtual bool ElementwiseConstant () const  override{ return true; }
-
-  // the old one, to be replaced
-  void NonZeroPattern (const class ProxyUserData & ud,
-                                      FlatVector<bool> nonzero,
-                                      FlatVector<bool> nonzero_deriv,
-                                      FlatVector<bool> nonzero_dderiv) const;
-
-  virtual void NonZeroPattern (const class ProxyUserData & ud,
-                               FlatVector<AutoDiffDiff<1,NonZero>> values) const override;
-  
-  virtual void NonZeroPattern (const class ProxyUserData & ud,
-                               FlatArray<FlatVector<AutoDiffDiff<1,NonZero>>> input,
-                               FlatVector<AutoDiffDiff<1,NonZero>> values) const override
-  {
-    NonZeroPattern (ud, values);
-    /*
-    Vector<bool> nz(values.Size()), nzd(values.Size()), nzdd(values.Size());
-    NonZeroPattern (ud, nz, nzd, nzdd);
-    for (size_t i = 0; i < values.Size(); i++)
-      {
-        values(i).Value() = nz(i);
-        values(i).DValue(0) = nzd(i);
-        values(i).DDValue(0) = nzdd(i);
-      }
-    */
-  }
-
-  
-  virtual shared_ptr<CoefficientFunction>
-  Diff (const CoefficientFunction * var, shared_ptr<CoefficientFunction> dir) const override;
-};
-
-
-  class SumOfIntegrals;
-  class DualProxyFunction : public ProxyFunction
-  {
-  public:
-    DualProxyFunction(const ProxyFunction & proxy)
-      : ProxyFunction(proxy) { ; }
-
-    shared_ptr<SumOfIntegrals> operator() (shared_ptr<CoefficientFunction> u) const;
-  };
-
-
-  
-class ProxyUserData
-{
-  FlatArray<const ProxyFunction*> remember_first;
-  FlatArray<FlatMatrix<double>> remember_second;
-  FlatArray<FlatMatrix<SIMD<double>>> remember_asecond;
-
-  FlatArray<const CoefficientFunction*> remember_cf_first;
-  FlatArray<FlatMatrix<double>> remember_cf_second;  
-  FlatArray<FlatMatrix<SIMD<double>>> remember_cf_asecond;
-  FlatArray<bool> remember_cf_computed;
-public:
-  class ProxyFunction * testfunction = nullptr;
-  int test_comp;
-  class ProxyFunction * trialfunction = nullptr;
-  int trial_comp;
-  int eval_deriv = 0; // 0 .. evaluate bfi, 1 .. deriv, 2 .. second order deriv
-  const FiniteElement * fel = nullptr;
-  FlatArray<pair<const CoefficientFunction*, void*>> caches;
-
-  FlatVector<double> *trial_elvec = nullptr, *test_elvec = nullptr; // for shape-wise evaluate
-  LocalHeap * lh = nullptr;
-
-  
-  ProxyUserData ()
-    : remember_first(0,nullptr), remember_second(0,nullptr), remember_asecond(0,nullptr),
-      remember_cf_first(0, nullptr), remember_cf_second(0,nullptr),remember_cf_asecond(0,nullptr), remember_cf_computed(0, nullptr)
-  { ; }
-  ProxyUserData (size_t ntrial, size_t ncf, LocalHeap & lh)
-    : remember_first(ntrial, lh), remember_second(ntrial, lh),
-      remember_asecond(ntrial, lh),
-      remember_cf_first(ncf, lh), remember_cf_second(ncf, lh),
-      remember_cf_asecond(ncf, lh),      
-      remember_cf_computed(ncf, lh)
-  { remember_first = nullptr; remember_cf_first = nullptr; }
-
-  ProxyUserData (int ntrial, LocalHeap & lh)
-    : ProxyUserData (ntrial, 0, lh) { ; } 
-  
-  void AssignMemory (const ProxyFunction * proxy, size_t h, size_t w, LocalHeap & lh)
-  {
-    for (size_t i = 0; i < remember_first.Size(); i++)
-      {
-        if (remember_first[i] == nullptr)
-          {
-            remember_first[i] = proxy;
-            new (&remember_second[i]) FlatMatrix<> (h, w, lh);
-            new (&remember_asecond[i]) FlatMatrix<SIMD<double>> (w, (h+SIMD<double>::Size()-1)/SIMD<double>::Size(), lh);
-            return;
-          }
-      }
-    throw Exception ("no space for userdata - memory available");
-  }
-
-  void AssignMemory (const ProxyFunction * proxy, FlatMatrix<SIMD<double>> mat)
-  {
-    for (size_t i = 0; i < remember_first.Size(); i++)
-      {
-        if (remember_first[i] == nullptr || remember_first[i] == proxy)
-          {
-            remember_first[i] = proxy;
-            new (&remember_asecond[i]) FlatMatrix<SIMD<double>> (mat);
-            return;
-          }
-      }
-    throw Exception ("no space for userdata - memory available");
-  }
-
-  
-  void AssignMemory (const CoefficientFunction * cf, size_t h, size_t w, LocalHeap & lh)
-  {
-    for (size_t i = 0; i < remember_cf_first.Size(); i++)
-      {
-        if (remember_cf_first[i] == nullptr)
-          {
-            remember_cf_first[i] = cf;
-            new (&remember_cf_second[i]) FlatMatrix<double> (h, w, lh);            
-            new (&remember_cf_asecond[i]) FlatMatrix<SIMD<double>> (w, (h+SIMD<double>::Size()-1)/SIMD<double>::Size(), lh);
-            remember_cf_computed[i] = false;
-            return;
-          }
-      }
-    throw Exception ("no space for userdata - memory available");
-  }
-
-  void AssignMemory (const CoefficientFunction * cf, FlatMatrix<SIMD<double>> mat)
-  {
-    for (size_t i = 0; i < remember_cf_first.Size(); i++)
-      {
-        if (remember_cf_first[i] == nullptr || remember_cf_first[i] == cf)
-          {
-            remember_cf_first[i] = cf;
-            new (&remember_cf_asecond[i]) FlatMatrix<SIMD<double>> (mat);
-            remember_cf_computed[i] = true;            
-            return;
-          }
-      }
-    throw Exception ("no space for userdata - memory available");
-  }
-
-  
-
-  bool HasMemory (const ProxyFunction * proxy) const
-  {
-    return remember_first.Contains(proxy);
-  }
-  bool HasMemory (const CoefficientFunction * cf) const
-  {
-    return remember_cf_first.Contains(cf);
-  }
-  FlatMatrix<> GetMemory (const ProxyFunction * proxy) const
-  {
-    return remember_second[remember_first.PosSure(proxy)];
-  }
-  FlatMatrix<SIMD<double>> GetAMemory (const ProxyFunction * proxy) const
-  {
-    return remember_asecond[remember_first.PosSure(proxy)];
-  }
-  FlatMatrix<double> GetMemory (const CoefficientFunction * cf) const
-  {
-    return remember_cf_second[remember_cf_first.PosSure(cf)];
-  }
-  FlatMatrix<SIMD<double>> GetAMemory (const CoefficientFunction * cf) const
-  {
-    return remember_cf_asecond[remember_cf_first.PosSure(cf)];
-  }
-  bool Computed (const CoefficientFunction * cf) const
-  {
-    return remember_cf_computed[remember_cf_first.PosSure(cf)];
-  }
-  void SetComputed (const CoefficientFunction * cf, bool val = true) const
-  {
-    remember_cf_computed[remember_cf_first.PosSure(cf)] = val;
-  }
-};
-
-  
-
-
-
-
-
-  class SymbolicLinearFormIntegrator : public LinearFormIntegrator
-  {
-  protected:
-    shared_ptr<CoefficientFunction> cf;
-    Array<ProxyFunction*> proxies;
-    Array<CoefficientFunction*> gridfunction_cfs;
-    Array<CoefficientFunction*> cache_cfs;
-    Array<shared_ptr<CoefficientFunction>> dcf_dtest;
-
-    VorB vb;
-    // bool element_boundary;
-    VorB element_vb;
-
-  public:
-    NGS_DLL_HEADER SymbolicLinearFormIntegrator (shared_ptr<CoefficientFunction> acf, VorB avb,
-                                                 VorB aelement_vb);
-
-    virtual VorB VB() const override { return vb; }
-    virtual string Name () const override { return string ("Symbolic LFI"); }
-    virtual int GetDimension() const override { return proxies[0]->Evaluator()->BlockDim(); }
-
-    virtual void 
-    CalcElementVector (const FiniteElement & fel,
-		       const ElementTransformation & trafo, 
-		       FlatVector<double> elvec,
-		       LocalHeap & lh) const override;
-      
-    virtual void 
-    CalcElementVector (const FiniteElement & fel,
-		       const ElementTransformation & trafo, 
-		       FlatVector<Complex> elvec,
-		       LocalHeap & lh) const override;
-
-    template <typename SCAL> 
-    void T_CalcElementVector (const FiniteElement & fel,
-                              const ElementTransformation & trafo, 
-                              FlatVector<SCAL> elvec,
-                              LocalHeap & lh) const;
-  };
-
-
-
-  class SymbolicBilinearFormIntegrator : public BilinearFormIntegrator
-  {
-  protected:
-    shared_ptr<CoefficientFunction> cf;
-    Array<ProxyFunction*> trial_proxies, test_proxies;
-    Array<CoefficientFunction*> gridfunction_cfs;
-    Array<CoefficientFunction*> cache_cfs;
-    Array<int> trial_cum, test_cum;   // cumulated dimension of proxies
-    VorB vb;           // on the boundary of the domain ? 
-    // bool element_boundary;
-    VorB element_vb;   // on the boundary of the element ? 
-    Matrix<bool> nonzeros;    // do components interact ?
-    Matrix<bool> nonzeros_deriv;   // do components interact ? 
-    Matrix<bool> nonzeros_proxies; // do proxies interact ?
-    Matrix<bool> diagonal_proxies; // do proxies interact diagonally ?
-    Matrix<bool> same_diffops; // are diffops the same ? 
-    bool elementwise_constant;
-
-    int trial_difforder, test_difforder;
-    bool is_symmetric;
-    bool has_interpolate; // is there an interpolate in the expression tree ? 
-    shared_ptr<BilinearFormIntegrator> linearization;
-    Array<shared_ptr<CoefficientFunction>> dcf_dtest;  // derivatives by test-functions
-    Matrix<shared_ptr<CoefficientFunction>> ddcf_dtest_dtrial;  // derivatives by test- and trial-functions
-  public:
-    NGS_DLL_HEADER SymbolicBilinearFormIntegrator (shared_ptr<CoefficientFunction> acf, VorB avb,
-                                                   VorB aelement_boundary);
-
-    virtual VorB VB() const override { return vb; }
-    virtual VorB ElementVB() const { return element_vb; }
-    virtual xbool IsSymmetric() const override { return is_symmetric ? xbool(true) : xbool(maybe); } 
-    virtual string Name () const override { return string ("Symbolic BFI"); }
-
-    using Integrator::GetIntegrationRule;
-    NGS_DLL_HEADER virtual const IntegrationRule& GetIntegrationRule (const FiniteElement & fel, LocalHeap & lh) const;
-    NGS_DLL_HEADER virtual const SIMD_IntegrationRule& Get_SIMD_IntegrationRule (const FiniteElement & fel, LocalHeap & lh) const;
-    // virtual IntegrationRule GetIntegrationRuleEB (const FiniteElement & fel, int facetnr, LocalHeap & lh) const;
-    // virtual SIMD_IntegrationRule Get_SIMD_IntegrationRuleEB (const FiniteElement & fel, int facetnr, LocalHeap & lh) const;
-    
-    virtual int GetDimension() const override { return trial_proxies[0]->Evaluator()->BlockDim(); }
-    void SetLinearization(shared_ptr<BilinearFormIntegrator> _lin)
-    { linearization = _lin; }
-
-    NGS_DLL_HEADER virtual void 
-    CalcElementMatrix (const FiniteElement & fel,
-		       const ElementTransformation & trafo, 
-		       FlatMatrix<double> elmat,
-		       LocalHeap & lh) const override;
-
-    NGS_DLL_HEADER virtual void 
-    CalcElementMatrix (const FiniteElement & fel,
-		       const ElementTransformation & trafo, 
-		       FlatMatrix<Complex> elmat,
-		       LocalHeap & lh) const override;    
-
-    NGS_DLL_HEADER virtual void 
-    CalcElementMatrixAdd (const FiniteElement & fel,
-                          const ElementTransformation & trafo, 
-                          FlatMatrix<double> elmat,
-                          bool & symmetric_so_far,                          
-                          LocalHeap & lh) const override;
-    
-    NGS_DLL_HEADER virtual void 
-    CalcElementMatrixAdd (const FiniteElement & fel,
-                          const ElementTransformation & trafo, 
-                          FlatMatrix<Complex> elmat,
-                          bool & symmetric_so_far,                          
-                          LocalHeap & lh) const override;    
-
-    
-    template <typename SCAL, typename SCAL_SHAPES, typename SCAL_RES>
-    void T_CalcElementMatrixAdd (const FiniteElement & fel,
-                                 const ElementTransformation & trafo, 
-                                 FlatMatrix<SCAL_RES> elmat,
-                                 bool & symmetric_so_far, 
-                                 LocalHeap & lh) const;
-
-    template <typename SCAL, typename SCAL_SHAPES, typename SCAL_RES>
-    void T_CalcElementMatrixEBAdd (const FiniteElement & fel,
-                                   const ElementTransformation & trafo, 
-                                   FlatMatrix<SCAL_RES> elmat,
-                                   LocalHeap & lh) const;
-
-    template <typename SCAL, typename SCAL_SHAPES, typename SCAL_RES>
-    void T_CalcElementMatrixAddShapeWise (const FiniteElement & fel,
-                                          const ElementTransformation & trafo, 
-                                          FlatMatrix<SCAL_RES> elmat,
-                                          LocalHeap & lh) const;
-
-    
-    NGS_DLL_HEADER virtual void 
-    CalcLinearizedElementMatrix (const FiniteElement & fel,
-                                 const ElementTransformation & trafo, 
-				 FlatVector<double> elveclin,
-                                 FlatMatrix<double> elmat,
-                                 LocalHeap & lh) const override;
-
-    NGS_DLL_HEADER virtual void
-    CalcLinearizedElementMatrix (const FiniteElement & fel,
-                                 const ElementTransformation & trafo,
-				 FlatVector<Complex> elveclin,
-                                 FlatMatrix<Complex> elmat,
-                                 LocalHeap & lh) const override;
-
-    template<typename SCAL> void
-    T_CalcLinearizedElementMatrixFrozen (const FiniteElement & fel,
-                                         const ElementTransformation & trafo,
-                                         FlatVector<SCAL> elveclin,
-                                         FlatMatrix<SCAL> elmat,
-                                         LocalHeap & lh) const;
-
-    template <typename SCAL, typename SCAL_SHAPES>
-    void T_CalcLinearizedElementMatrixEB (const FiniteElement & fel,
-                                          const ElementTransformation & trafo, 
-                                          FlatVector<double> elveclin,
-                                          FlatMatrix<double> elmat,
-                                          LocalHeap & lh) const;
-    
-    NGS_DLL_HEADER virtual void 
-    ApplyElementMatrix (const FiniteElement & fel, 
-			const ElementTransformation & trafo, 
-			const FlatVector<double> elx, 
-			FlatVector<double> ely,
-			void * precomputed,
-			LocalHeap & lh) const override;
-
-    template <typename SCAL, typename SCAL_SHAPES>
-    void T_ApplyElementMatrixEB (const FiniteElement & fel, 
-                                 const ElementTransformation & trafo, 
-                                 const FlatVector<double> elx, 
-                                 FlatVector<double> ely,
-                                 void * precomputed,
-                                 LocalHeap & lh) const;
-
-    NGS_DLL_HEADER virtual void 
-    ApplyElementMatrixTrans (const FiniteElement & fel, 
-                             const ElementTransformation & trafo, 
-                             const FlatVector<double> elx, 
-                             FlatVector<double> ely,
-                             void * precomputed,
-                             LocalHeap & lh) const override;
-    
-    template <typename SCAL, typename SCAL_SHAPES>
-    void T_ApplyElementMatrixTransEB (const FiniteElement & fel, 
-                                      const ElementTransformation & trafo, 
-                                      const FlatVector<double> elx, 
-                                      FlatVector<double> ely,
-                                      void * precomputed,
-                                      LocalHeap & lh) const;
-
-    
-    const auto & GetCoefficientFunction() { return cf; }
-    const auto & TrialProxies() { return trial_proxies; } 
-    const auto & TestProxies() { return test_proxies; } 
-    const auto & GridFunctionCoefficients() { return gridfunction_cfs; } 
-  };
-
-
-
-  class SymbolicFacetLinearFormIntegrator : public FacetLinearFormIntegrator
-  {
-    shared_ptr<CoefficientFunction> cf;
-    Array<ProxyFunction*> proxies;
-    Array<CoefficientFunction*> cache_cfs;
-    Array<int> test_cum;    // cumulated dimension of proxies
-    VorB vb;                // only BND supported by now
-    // bool element_boundary;  /// not needed (by now ???)
-    IntegrationRule ir;   // if non-empty use this integration-rule
-    SIMD_IntegrationRule simd_ir;   // if non-empty use this integration-rule
-
-  public:
-    SymbolicFacetLinearFormIntegrator (shared_ptr<CoefficientFunction> acf, VorB avb);
-
-    virtual VorB VB() const override { return vb; }
-    virtual bool BoundaryForm() const override { return vb == BND; }
-
-    NGS_DLL_HEADER void
-    CalcFacetVector (const FiniteElement & volumefel1, int LocalFacetNr1,
-			 const ElementTransformation & eltrans1, FlatArray<int> & ElVertices1,
-			 const FiniteElement & volumefel2, int LocalFacetNr2,
-			 const ElementTransformation & eltrans2, FlatArray<int> & ElVertices2,
-			 FlatVector<double> elvec,
-			 LocalHeap & lh) const override;   
-
-    NGS_DLL_HEADER void 
-    CalcFacetVector (const FiniteElement & volumefel1, int LocalFacetNr1,
-			 const ElementTransformation & eltrans1, FlatArray<int> & ElVertices1,
-			 const FiniteElement & volumefel2, int LocalFacetNr2,
-			 const ElementTransformation & eltrans2, FlatArray<int> & ElVertices2,	 
-			 FlatVector<Complex> elvec,
-			 LocalHeap & lh) const override;
-
-    NGS_DLL_HEADER void
-    CalcFacetVector(const FiniteElement & volumefel, int LocalFacetNr,
-                    const ElementTransformation & eltrans, FlatArray<int> & ElVertices,
-                    const ElementTransformation & seltrans,
-                    FlatVector<double> elvec,
-                    LocalHeap & lh) const override;
-
-    NGS_DLL_HEADER void
-    CalcFacetVector(const FiniteElement & volumefel, int LocalFacetNr,
-                    const ElementTransformation & eltrans, FlatArray<int> & ElVertices,
-                    const ElementTransformation & seltrans,
-                    FlatVector<Complex> elvec,
-                    LocalHeap & lh) const override;
-
-  private:
-    template<typename TSCAL>
-    void T_CalcFacetVector (const FiniteElement & fel1, int LocalFacetNr1,
-                       const ElementTransformation & trafo1, FlatArray<int> & ElVertices1,
-                       const FiniteElement & fel2, int LocalFacetNr2,
-                       const ElementTransformation & trafo2, FlatArray<int> & ElVertices2, 
-                       FlatVector<TSCAL> elvec,
-                       LocalHeap &lh) const;
-
-    template<typename TSCAL>
-    void T_CalcFacetVector (const FiniteElement & volumefel, int LocalFacetNr,
-                            const ElementTransformation & eltrans, FlatArray<int> & ElVertices,
-                            const ElementTransformation & seltrans,
-                            FlatVector<TSCAL> elvec,
-                            LocalHeap & lh) const;
-  };
-
-
-  
-
-  class SymbolicFacetBilinearFormIntegrator : public FacetBilinearFormIntegrator
-  {
-  protected:
-    shared_ptr<CoefficientFunction> cf;
-    Array<ProxyFunction*> trial_proxies, test_proxies;
-    Array<CoefficientFunction*> gridfunction_cfs;
-    Array<CoefficientFunction*> cache_cfs;
-    Array<int> trial_cum, test_cum;   // cumulated dimension of proxies
-    VorB vb;
-    bool element_boundary;
-    bool neighbor_testfunction;
-    Array<shared_ptr<CoefficientFunction>> dcf_dtest;  // derivatives by test-functions    
-  public:
-    NGS_DLL_HEADER SymbolicFacetBilinearFormIntegrator (shared_ptr<CoefficientFunction> acf, VorB avb, bool aelement_boundary);
-
-    virtual VorB VB() const { return vb; }
-    virtual bool BoundaryForm() const { return vb == BND; }
-    virtual xbool IsSymmetric() const { return maybe; } 
-    
-    virtual DGFormulation GetDGFormulation() const { return DGFormulation(neighbor_testfunction,
-                                                                          element_boundary); }
-    
-    NGS_DLL_HEADER virtual void
-    CalcFacetMatrix (const FiniteElement & volumefel1, int LocalFacetNr1,
-                     const ElementTransformation & eltrans1, FlatArray<int> & ElVertices1,
-                     const FiniteElement & volumefel2, int LocalFacetNr2,
-                     const ElementTransformation & eltrans2, FlatArray<int> & ElVertices2,
-                     FlatMatrix<double> elmat,
-                     LocalHeap & lh) const;
-
-    NGS_DLL_HEADER virtual void
-    CalcFacetMatrix (const FiniteElement & volumefel, int LocalFacetNr,
-                     const ElementTransformation & eltrans, FlatArray<int> & ElVertices,
-                     const ElementTransformation & seltrans, FlatArray<int> & SElVertices,  
-                     FlatMatrix<double> elmat,
-                     LocalHeap & lh) const;
-
-    NGS_DLL_HEADER virtual void
-    CalcFacetMatrix (const FiniteElement & volumefel1, int LocalFacetNr1,
-                     const ElementTransformation & eltrans1, FlatArray<int> & ElVertices1,
-                     const FiniteElement & volumefel2, int LocalFacetNr2,
-                     const ElementTransformation & eltrans2, FlatArray<int> & ElVertices2,
-                     FlatMatrix<Complex> elmat,
-                     LocalHeap & lh) const;
-
-    NGS_DLL_HEADER virtual void
-    CalcFacetMatrix (const FiniteElement & volumefel, int LocalFacetNr,
-                     const ElementTransformation & eltrans, FlatArray<int> & ElVertices,
-                     const ElementTransformation & seltrans, FlatArray<int> & SElVertices,  
-                     FlatMatrix<Complex> elmat,
-                     LocalHeap & lh) const;
-
-    NGS_DLL_HEADER virtual void
-    CalcLinearizedFacetMatrix (const FiniteElement & volumefel, int LocalFacetNr,
-                               const ElementTransformation & eltrans, FlatArray<int> & ElVertices,
-                               const ElementTransformation & seltrans, FlatArray<int> & SElVertices,  
-                               FlatVector<double> vec, FlatMatrix<double> elmat,
-                               LocalHeap & lh) const;
-    
-    NGS_DLL_HEADER virtual void
-    ApplyFacetMatrix (const FiniteElement & volumefel1, int LocalFacetNr1,
-                      const ElementTransformation & eltrans1, FlatArray<int> & ElVertices1,
-                      const FiniteElement & volumefel2, int LocalFacetNr2,
-                      const ElementTransformation & eltrans2, FlatArray<int> & ElVertices2,
-                      FlatVector<double> elx, FlatVector<double> ely,
-                      LocalHeap & lh) const;
-
-    NGS_DLL_HEADER virtual void
-    CalcTraceValues (const FiniteElement & volumefel, int LocalFacetNr,
-		     const ElementTransformation & eltrans, FlatArray<int> & ElVertices,
-		     FlatVector<double> & trace, FlatVector<double> elx, LocalHeap & lh) const;
-
-    NGS_DLL_HEADER virtual void
-    ApplyFromTraceValues (const FiniteElement & volumefel, int LocalFacetNr,
-			  const ElementTransformation & eltrans, FlatArray<int> & ElVertices,
-			  FlatVector<double> trace,
-			  FlatVector<double> elx, FlatVector<double> ely, 
-			  LocalHeap & lh) const;
-    
-    NGS_DLL_HEADER virtual void
-    ApplyFacetMatrix (const FiniteElement & volumefel, int LocalFacetNr,
-                      const ElementTransformation & eltrans, FlatArray<int> & ElVertices,
-                      const ElementTransformation & seltrans, FlatArray<int> & SElVertices,
-                      FlatVector<double> elx, FlatVector<double> ely,
-                      LocalHeap & lh) const;
-
-  private:
-    template<typename TSCAL, typename SCAL_SHAPES = double>
-    void T_CalcFacetMatrix(const FiniteElement & volumefel1, int LocalFacetNr1,
-                           const ElementTransformation & eltrans1, FlatArray<int> & ElVertices1,
-                           const FiniteElement & volumefel2, int LocalFacetNr2,
-                           const ElementTransformation & eltrans2, FlatArray<int> & ElVertices2,
-                           FlatMatrix<TSCAL> elmat,
-                           LocalHeap & lh) const;
-
-    template<typename TSCAL, typename SCAL_SHAPES = double>
-    void T_CalcFacetMatrix(const FiniteElement & volumefel, int LocalFacetNr,
-                           const ElementTransformation & eltrans, FlatArray<int> & ElVertices,
-                           const ElementTransformation & seltrans, FlatArray<int> & SElVertices,  
-                           FlatMatrix<TSCAL> elmat,
-                           LocalHeap & lh) const;
-  };
-
-  class SymbolicEnergy : public BilinearFormIntegrator
-  {
-  protected:
-    shared_ptr<CoefficientFunction> cf;
-    VorB vb;
-    Array<ProxyFunction*> trial_proxies;
-    VorB element_vb;    
-
-    Timer<TNoTracing> timer{"SymbolicEnergy"};
-    Array<int> trial_cum;     // cumulated dimension of proxies
-    Matrix<bool> nonzeros;    // do components interact ? 
-    Matrix<bool> nonzeros_proxies; // do proxies interact ?
-    Array<shared_ptr<CoefficientFunction>> dcf, ddcf;
-    
-  public:
-    SymbolicEnergy (shared_ptr<CoefficientFunction> acf, VorB avb, VorB aelement_vb);
-
-    virtual VorB VB() const { return vb; }
-    virtual xbool IsSymmetric() const { return true; } 
-    virtual string Name () const { return string ("Symbolic Energy"); }
-
-
-    using Integrator::GetIntegrationRule;
-    NGS_DLL_HEADER virtual const IntegrationRule& GetIntegrationRule (const FiniteElement & fel, LocalHeap & lh) const;
-    NGS_DLL_HEADER virtual const SIMD_IntegrationRule& Get_SIMD_IntegrationRule (const FiniteElement & fel, LocalHeap & lh) const;
-    
-    virtual void 
-    CalcElementMatrix (const FiniteElement & fel,
-		       const ElementTransformation & trafo, 
-		       FlatMatrix<double> elmat,
-		       LocalHeap & lh) const;
-
-    virtual void 
-    CalcLinearizedElementMatrix (const FiniteElement & fel,
-                                 const ElementTransformation & trafo, 
-				 FlatVector<double> elveclin,
-                                 FlatMatrix<double> elmat,
-                                 LocalHeap & lh) const;
-
-    void AddLinearizedElementMatrix (const FiniteElement & fel,
-                                     ProxyUserData & ud, 
-                                     const BaseMappedIntegrationRule & mir, 
-                                     FlatVector<double> elveclin,
-                                     FlatMatrix<double> elmat,
-                                     LocalHeap & lh) const;
-
-    void AddLinearizedElementMatrix (const FiniteElement & fel,
-                                     const ElementTransformation & trafo, 
-                                     const SIMD_BaseMappedIntegrationRule & mir, 
-                                     FlatVector<double> elveclin,
-                                     FlatMatrix<double> elmat,
-                                     LocalHeap & lh) const;
-
-
-    virtual double Energy (const FiniteElement & fel, 
-			   const ElementTransformation & trafo, 
-                           FlatVector<double> elx, 
-			   LocalHeap & lh) const;
-
-    virtual void 
-    ApplyElementMatrix (const FiniteElement & fel, 
-			const ElementTransformation & trafo, 
-			const FlatVector<double> elx, 
-			FlatVector<double> ely,
-			void * precomputed,
-			LocalHeap & lh) const;
-  };
-  
-
-
-
-}
-
-
-#endif