ngsolve 6.2.2501.post21.dev1__cp313-cp313-manylinux_2_28_x86_64.whl → 6.2.2501.post80.dev1__cp313-cp313-manylinux_2_28_x86_64.whl

{ngsolve-6.2.2501.post21.dev1.data → ngsolve-6.2.2501.post80.dev1.data}/data/include/netgen/bdbintegrator.hpp

@@ -1433,7 +1433,8 @@ class T_BIntegrator : public LinearFormIntegrator
 {
 protected:
   DVecOp dvecop;
-  DifferentialOperator * diffop = new T_DifferentialOperator<DIFFOP>;
+  // DifferentialOperator * diffop = new T_DifferentialOperator<DIFFOP>;
+  unique_ptr<DifferentialOperator> diffop = make_unique<T_DifferentialOperator<DIFFOP>>();  
 public:
   enum { DIM_SPACE = DIFFOP::DIM_SPACE };
   enum { DIM_ELEMENT = DIFFOP::DIM_ELEMENT };

{ngsolve-6.2.2501.post21.dev1.data → ngsolve-6.2.2501.post80.dev1.data}/data/include/netgen/coefficient.hpp

@@ -1293,11 +1293,24 @@ public:
   
   virtual shared_ptr<CoefficientFunction>
   Diff (const CoefficientFunction * var, shared_ptr<CoefficientFunction> dir) const override
-  { throw Exception ("unarycf "+name+" does not provide a derivative"); }
+  {
+    if (this == var) return dir;
+    return CWMult (lam.Diff(c1), c1->Diff(var, dir));
+    
+    // throw Exception ("unarycf "+name+" does not provide a derivative");
+  }
 
   virtual shared_ptr<CoefficientFunction>
   DiffJacobi (const CoefficientFunction * var, T_DJC & cache) const override
-  { return BASE::DiffJacobi(var, cache); }
+  {
+    if (this == var) return make_shared<ConstantCoefficientFunction> (1);
+    if (this->Dimensions().Size() == 0)
+      return lam.Diff(c1) * c1->DiffJacobi(var, cache);
+    else
+      return MakeMultDiagMatCoefficientFunction (lam.Diff(c1), 
+                                             c1->DiffJacobi(var, cache));
+    // return BASE::DiffJacobi(var, cache);
+  }
 
   
   /*
@@ -1775,6 +1788,16 @@ INLINE shared_ptr<CoefficientFunction> BinaryOpCF(shared_ptr<CoefficientFunction
                                             shared_ptr<CoefficientFunction> vec,
                                             int index);
 
+  // diag(c1) * c2
+  // general tensor (TODO)
+  // C = A*B in sense of
+  // C_ijk = A_ij B_ik
+  //  with i.. single index, and j,k multi-index
+  NGS_DLL_HEADER shared_ptr<CoefficientFunction>
+  MakeMultDiagMatCoefficientFunction (shared_ptr<CoefficientFunction> c1,
+                                  shared_ptr<CoefficientFunction> c2);
+
+
   NGS_DLL_HEADER shared_ptr<CoefficientFunction>
   MakeCoordinateCoefficientFunction (int comp);
 
@@ -1848,6 +1871,10 @@ INLINE shared_ptr<CoefficientFunction> BinaryOpCF(shared_ptr<CoefficientFunction
   NGS_DLL_HEADER
   shared_ptr<CoefficientFunction> UnitVectorCF (int dim, int coord);
 
+  NGS_DLL_HEADER
+  shared_ptr<CoefficientFunction> OneVectorCF (FlatArray<int> dims);
+
+
   NGS_DLL_HEADER
   shared_ptr<CoefficientFunction> LeviCivitaCF(int dimension);
 

{ngsolve-6.2.2501.post21.dev1.data → ngsolve-6.2.2501.post80.dev1.data}/data/include/netgen/coefficient_impl.hpp

@@ -10,6 +10,7 @@ namespace ngfem
   {
     template <typename T> T operator() (T x) const { return x; }
     static string Name() { return  " "; }
+    template <typename T> T Diff (T x) const { throw Exception("no GenericIdentity::Diff"); }        
     void DoArchive(Archive& ar) {}
   };
 

{ngsolve-6.2.2501.post21.dev1.data → ngsolve-6.2.2501.post80.dev1.data}/data/include/netgen/coefficient_stdmath.hpp

@@ -13,12 +13,14 @@ namespace ngfem
   
   struct GenericSin {
     template <typename T> T operator() (T x) const { return sin(x); }
+    template <typename T> T Diff (T x) const { return cos(x); }    
     static string Name() { return "sin"; }
     void DoArchive(Archive& ar) {}
   };
 
   struct GenericCos {
     template <typename T> T operator() (T x) const { return cos(x); }
+    template <typename T> T Diff (T x) const { return -sin(x); }    
     static string Name() { return "cos"; }
     void DoArchive(Archive& ar) {}
   };
@@ -52,12 +54,14 @@ namespace ngfem
 
   struct GenericSinh {
     template <typename T> T operator() (T x) const { return sinh(x); }
+    template <typename T> T Diff (T x) const { return cosh(x); }            
     static string Name() { return "sinh"; }
     void DoArchive(Archive& ar) {}
   };
   
   struct GenericCosh {
     template <typename T> T operator() (T x) const { return cosh(x); }
+    template <typename T> T Diff (T x) const { return sinh(x); }        
     static string Name() { return "cosh"; }
     void DoArchive(Archive& ar) {}
   };
@@ -66,6 +70,7 @@ namespace ngfem
 
   struct GenericExp {
     template <typename T> T operator() (T x) const { return exp(x); }
+    template <typename T> T Diff (T x) const { return exp(x); }
     static string Name() { return "exp"; }
     void DoArchive(Archive& ar) {}
   };
@@ -73,6 +78,9 @@ namespace ngfem
   struct GenericLog {
     template <typename T> T operator() (T x) const { return log(x); }
     static string Name() { return "log"; }
+    auto Diff (shared_ptr<CoefficientFunction> x) const {
+      return OneVectorCF(x->Dimensions()) / x;
+    }    
     void DoArchive(Archive& ar) {}
   };
 
@@ -94,6 +102,7 @@ struct GenericFloor {
   SIMD<Complex> operator() (SIMD<Complex> x) const { throw ExceptionNOSIMD("no floor for simd"); }  
   // AutoDiff<1> operator() (AutoDiff<1> x) const { throw Exception("no floor for AD"); }
   AutoDiffDiff<1> operator() (AutoDiffDiff<1> x) const { throw Exception("no floor for ADD"); }
+  template <typename T> T Diff (T x) const { throw Exception("Generic Floor not differentiable"); }  
   static string Name() { return "floor"; }
   void DoArchive(Archive& ar) {}
 };
@@ -104,6 +113,7 @@ struct GenericCeil {
   SIMD<Complex> operator() (SIMD<Complex> x) const { throw ExceptionNOSIMD("no ceil for simd"); }  
   // AutoDiff<1> operator() (AutoDiff<1> x) const { throw Exception("no ceil for AD"); }
   AutoDiffDiff<1> operator() (AutoDiffDiff<1> x) const { throw Exception("no ceil for ADD"); }
+  template <typename T> T Diff (T x) const { throw Exception("Generic Ceil not differentiable"); }    
   static string Name() { return "ceil"; }
   void DoArchive(Archive& ar) {}
 };

{ngsolve-6.2.2501.post21.dev1.data → ngsolve-6.2.2501.post80.dev1.data}/data/include/netgen/contact.hpp

@@ -161,10 +161,10 @@ namespace ngcomp
     bool draw_pairs = false;
     Array<Vec<3>> primary_points;
     Array<Vec<3>> secondary_points;
-    bool volume;
+    bool volume, element_boundary;
   public:
     void Draw();
-    ContactBoundary(Region _master, Region _other, bool draw_pairs = false, bool _volume=false);
+    ContactBoundary(Region _master, Region _other, bool draw_pairs = false, bool _volume=false, bool element_boundary=false);
 
     ~ContactBoundary();
 

ngsolve-6.2.2501.post80.dev1.data/data/include/netgen/ectypes.hpp

@@ -0,0 +1,121 @@
+#include "expr.hpp"
+
+// arithmetics with error control (better say error monitoring)
+
+
+namespace ngbla
+{
+  
+  
+  class EC_double
+  {
+    double val;
+    double err;
+  public:
+    EC_double () : val(0), err(0) { }
+    EC_double (double a)
+      : val(a), err(fabs(a)*1e-16) { }
+    EC_double (double a, double aerr)
+      : val(a), err(aerr)
+    {
+      Check();
+    }
+    EC_double (EC_double&) = default;    
+
+    EC_double & operator= (EC_double&) = default;
+    EC_double & operator= (double a)
+    {
+      val = a; err = fabs(a)*1e-16;
+      return *this;
+    }
+    
+    double Val() const { return val; }
+    double Err() const { return err; }    
+    operator double() const { return val; }
+
+    EC_double & operator*= (EC_double b)
+    {
+      *this = EC_double(*this)*b;
+      return *this;
+    }
+
+    EC_double & operator+= (EC_double b)
+    {
+      val += b.Val();
+      err += b.Err();
+      Check();
+      return *this;
+    }
+    
+    EC_double & operator-= (EC_double b)
+    {
+      *this = EC_double(*this) + (-b);
+      return *this;
+    }
+
+    EC_double operator- () const
+    {
+      return EC_double(-val, err);
+    }
+
+    void Check() const
+    {
+      if (err > 1e-4 * abs(val))
+        {
+          // throw Exception("roundoff is big, val = "+ToString(val)+", err = ", ToString(err));
+          cout << "roundoff is big, val = "+ToString(val)+", err = " + ToString(err) << endl;
+        }
+    }
+  };
+
+
+  inline EC_double operator* (EC_double a, EC_double b)
+  {
+    return EC_double(a.Val()*b.Val(), abs(a.Val())*b.Err()+abs(b.Val())*a.Err());
+  }
+
+  inline EC_double operator* (EC_double a, double b)
+  {
+    return a * EC_double(b);
+  }
+
+  inline EC_double operator* (double b, EC_double a)
+  {
+    return a * EC_double(b);
+  }
+  
+  inline EC_double operator+ (EC_double a, EC_double b)
+  {
+    return EC_double(a.Val()+b.Val(), a.Err()+b.Err());
+  }
+
+  typedef std::complex<EC_double> EC_Complex;
+
+  inline auto operator* (double a, EC_Complex b)
+  {
+    return EC_double(a) * b;
+  }
+
+  inline auto operator* (EC_Complex a, const Complex b)
+  {
+    return a*EC_Complex(b);
+  }
+
+  inline double L2Norm2 (EC_Complex val)
+  {
+    return sqr(val.real().Val()) + sqr(val.imag().Val());
+  }
+
+
+  // typedef std::complex<__128float> Complex128;
+  // typedef std::complex<double> Complex128;  
+
+
+
+  
+  template<> struct is_scalar_type<ngfem::EC_Complex> { static constexpr bool value = true; };
+  template<> struct is_scalar_type<ngfem::EC_double> { static constexpr bool value = true; };
+  template <> inline constexpr bool IsComplex<ngfem::EC_Complex> () { return true; }
+
+  
+}

{ngsolve-6.2.2501.post21.dev1.data → ngsolve-6.2.2501.post80.dev1.data}/data/include/netgen/elementbyelement.hpp

@@ -144,8 +144,8 @@ namespace ngla
 
     virtual BaseMatrix::OperatorInfo GetOperatorInfo () const override;
     
-    virtual void MultAdd (double s, const BaseVector & x, BaseVector & y) const override;
-    virtual void MultTransAdd (double s, const BaseVector & x, BaseVector & y) const override;
+    virtual void MultAdd (SCAL s, const BaseVector & x, BaseVector & y) const override;
+    virtual void MultTransAdd (SCAL s, const BaseVector & x, BaseVector & y) const override;
     
     virtual AutoVector CreateRowVector () const override;
     virtual AutoVector CreateColVector () const override;

{ngsolve-6.2.2501.post21.dev1.data → ngsolve-6.2.2501.post80.dev1.data}/data/include/netgen/h1lofe.hpp

@@ -1095,6 +1095,9 @@ namespace ngfem
   H1LOFE_EXTERN template class T_ScalarFiniteElement<FE_TSegmL2<2>,ET_SEGM>;
   H1LOFE_EXTERN template class T_ScalarFiniteElement<FE_TSegmL2<3>,ET_SEGM>;
 
+  H1LOFE_EXTERN template class T_ScalarFiniteElement<ScalarFE<ET_POINT, 1>, ET_POINT, ScalarFiniteElement<0>>;
+  H1LOFE_EXTERN template class T_ScalarFiniteElement<ScalarFE<ET_TRIG, 2>, ET_TRIG, ScalarFiniteElement<2>>;
+
   H1LOFE_EXTERN template class T_ScalarFiniteElement<ScalarFE<ET_TRIG,0>,ET_TRIG>;
   H1LOFE_EXTERN template class T_ScalarFiniteElement<ScalarFE<ET_TRIG,1>,ET_TRIG>;
   // H1LOFE_EXTERN template class T_ScalarFiniteElement<FE_Trig2,ET_TRIG>;