ngsolve 6.2.2506.post216.dev0__cp314-cp314-manylinux_2_28_x86_64.whl

ngsolve-6.2.2506.post216.dev0.data/data/lib/python3.14/site-packages/ngsolve/__expr.py

@@ -0,0 +1,181 @@
+###############################################
+# Expression classes                          
+###############################################
+
+def Expr(a):
+    if isinstance(a, BaseExpr):
+        return a
+    try:
+        return a.expr
+    except:
+        raise TypeError('cannot convert ' + str(type(a)) + ' to expression')
+    
+def expr_add(a,b):
+    return Expr(a) + Expr(b)
+
+def expr_sub(a,b):
+    return Expr(a) - Expr(b)
+
+def expr_neg(a):
+    return -Expr(a)
+
+def expr_mul(a,b):
+    return Expr(a) * Expr(b)
+
+def expr_rmul(b,a): # rmul -> swap a,b
+    return a * Expr(b)
+
+def expr_data(a,b):
+    Expr(b).AssignTo(Expr(a))
+
+class BaseExpr:
+    def copy(self):
+        return self.__class__(self.a, self.s)
+
+    def Scale(self, s):
+        res = self.copy()
+        res.s*=s
+        return res
+
+    def __init__(self, a, s=1.0):
+        self.a = a
+        self.s = s
+    
+    def __rmul__(self, other):
+        return self.Scale(other)
+
+    def __add__(self, other):
+        return SumExpr(self, Expr(other))
+
+    def __sub__(self, other):
+        return SumExpr(self, Expr(other).Scale(-1))
+    
+    def __neg__(self):
+        return self.Scale(-1)
+    
+    def __str__(self):
+        return str(self.s) + '*' +str(self.a)
+
+    def __len__(self):
+        return len(self.a)
+
+    def T(self):
+        return TransExpr(self)
+
+class VecExpr(BaseExpr):
+    def AssignTo(self, v, s = 1.0):
+        v.a.Assign(self.a,s*self.s)
+    
+    def AddTo(self, v, s = 1.0):
+        try:
+            v.a.Add(self.a,s*self.s)     
+        except:
+            print ("WARNING: add to exception")
+            v.a += self.a
+
+
+class MatExpr(BaseExpr):
+    def MultScale(self, s, x, y):
+        self.a.MultScale(s*self.s*x.s,x.a,y.a)
+
+    def MultTrans(self, s, x, y):
+        self.a.MultTrans(s*self.s*x.s,x.a,y.a)
+
+    def MultAdd(self, s, x, y):
+        self.a.MultAdd(s*self.s*x.s,x.a,y.a)
+
+    def MultTransAdd(self, s, x, y):
+        self.a.MultTransAdd(s*self.s*x.s,x.a,y.a)
+
+    def __mul__(self, other):
+        if isinstance(Expr(other), VecExpr):
+            return MatVecExpr(self, Expr(other))
+        try:
+            return self.Scale(float(other))
+        except:
+            return None
+
+    def __len__(self):
+        return self.a.Height()
+
+
+class TransExpr(MatExpr):
+    def __init__(self, matexpr, s=1.0):
+        self.a = Expr(matexpr).a
+        self.s = s*Expr(matexpr).s
+
+    def MultScale(self, s, x, y):
+        self.a.MultTrans(s*self.s,x.a,y.a)
+
+    def MultTrans(self, s, x, y):
+        self.a.MultScale(s*self.s,x.a,y.a)
+
+    def MultAdd(self, s, x, y):
+        self.a.MultTransAdd(s*self.s,x.a,y.a)
+
+    def MultTransAdd(self, s, x, y):
+        self.a.MultAdd(s*self.s,x.a,y.a)
+    
+class BinExpr(BaseExpr):
+    def __init__(self, a,b):
+        self.a = Expr(a)
+        self.b = Expr(b)
+
+    def copy(self):
+        return BinExpr(a,b)
+
+    def __str__(self):
+        return str(self.a) + ' op ' + str(self.b)
+
+
+class SumExpr(BinExpr):
+    def Scale(self, s):
+        return SumExpr(self.a.Scale(s), self.b.Scale(s))
+
+    def AssignTo(self, v, s = 1.0):
+        self.a.AssignTo(v, s)
+        self.b.AddTo(v, s)
+
+    def AddTo(self, v, s = 1.0):
+        self.a.AddTo(v, s)
+        self.b.AddTo(v, s)
+
+    def __str__(self):
+        return str(self.a) + ' + ' + str(self.b)
+        
+
+class MatVecExpr(BinExpr):
+    def Scale(self, s):
+        return MatVecExpr(self.a.Scale(s), self.b)
+
+    def AssignTo(self, v, s = 1.0):
+        self.a.MultScale(s,self.b,v)
+
+    def AddTo(self, v, s = 1.0):
+        self.a.MultAdd(s,self.b,v)
+
+    def __str__(self):
+        return str(self.a) + ' * ' + str(self.b)
+
+        
+def GetSlice(self, index):
+    if not isinstance(index,slice):
+        return self.Get(index)
+    index = index.indices(len(self))
+    if(index[2]!=1):
+        print("Slicing with 3 parameters not supported!")
+        return none
+    return self.Range(index[0], index[1])
+
+def SetSlice(self, index, other):
+    if not isinstance(index,slice):
+        self.Set(index, other)
+        return
+    index = index.indices(len(self))
+    if(index[2]!=1):
+        print("Slicing with 3 parameters not supported!")
+        return none
+    Expr(other).AssignTo(self.Range(index[0], index[1]).expr)
+
+
+

ngsolve-6.2.2506.post216.dev0.data/data/lib/python3.14/site-packages/ngsolve/__init__.py

@@ -0,0 +1,148 @@
+"""
+NGSolve
+=======
+
+A high order finite element library
+
+Modules:
+ngsolve.bla .... simple vectors and matrices
+ngsolve.fem .... finite elements and integrators
+ngsolve.comp ... function spaces, forms
+"""
+import atexit
+import os, sys
+
+from . import config
+
+import netgen
+
+if config.is_python_package and sys.platform.startswith('win'):
+    netgen_dir = os.path.dirname(netgen.__file__)
+    os.add_dll_directory(netgen_dir)
+    os.environ["PATH"] += os.pathsep + netgen_dir
+
+if config.USE_MKL and config.MKL_LINK == 'sdl':
+    import importlib.metadata
+    try:
+        importlib.metadata.version('mkl')
+        import ctypes
+        for f in importlib.metadata.files('intel_openmp'):
+            if f.match('*libiomp?.so') or f.match('*libiomp?md.dll'):
+                ctypes.CDLL(str(f.locate()), mode=ctypes.RTLD_GLOBAL)
+        for f in importlib.metadata.files('mkl'):
+            if f.match('*mkl_rt*'):
+                ctypes.CDLL(str(f.locate()), mode=ctypes.RTLD_GLOBAL)
+    except importlib.metadata.PackageNotFoundError:
+        pass
+
+from .ngslib import __version__, ngstd, bla, la, fem, comp, solve
+
+from netgen import Redraw, TimeFunction
+
+from pyngcore import BitArray, TaskManager, SetNumThreads, PajeTrace, Timers, Timer
+from .ngstd import IntRange
+from .bla import Matrix, Vector, InnerProduct, Norm
+from .la import BaseMatrix, BaseVector, BlockVector, MultiVector, BlockMatrix, \
+    CreateVVector, CGSolver, QMRSolver, GMRESSolver, ArnoldiSolver, \
+    Projector, DiagonalMatrix, IdentityMatrix, Embedding, PermutationMatrix, \
+    ConstEBEMatrix, ParallelMatrix, PARALLEL_STATUS
+from .fem import BFI, LFI, CoefficientFunction, Parameter, ParameterC, ET, \
+    POINT, SEGM, TRIG, QUAD, TET, PRISM, PYRAMID, HEX, CELL, FACE, EDGE, \
+    VERTEX, FACET, ELEMENT, sin, cos, tan, atan, acos, asin, sinh, cosh, \
+    exp, log, sqrt, erf, floor, ceil, Conj, atan2, pow, Sym, Skew, Id, Trace, Inv, Det, Cof, Cross, \
+    Zero as ZeroCF, \
+    specialcf, BlockBFI, BlockLFI, CompoundBFI, CompoundLFI, BSpline, \
+    IntegrationRule, IfPos, VoxelCoefficient, CacheCF, PlaceholderCF
+from .comp import VOL, BND, BBND, BBBND, COUPLING_TYPE, ElementId, \
+    BilinearForm, LinearForm, GridFunction, Preconditioner, \
+    MultiGridPreconditioner, ElementId, FESpace, ProductSpace, H1, HCurl, \
+    HDiv, L2, VectorH1, VectorL2, SurfaceL2, TangentialSurfaceL2, HDivDiv, HCurlCurl, HCurlDiv, \
+    HDivSurface, HDivDivSurface, FacetFESpace, TangentialFacetFESpace, \
+    NormalFacetFESpace, NormalFacetSurface, \
+    FacetSurface, VectorSurfaceL2, VectorFacetFESpace, VectorFacetSurface, \
+    NodalFESpace, VectorNodalFESpace, H1LumpingFESpace, \
+    NumberSpace, Periodic, Discontinuous, Hidden, VectorValued, MatrixValued, Compress, \
+    CompressCompound, PlateauFESpace, BoundaryFromVolumeCF, Interpolate, Variation, \
+    Integrate, Region, SymbolicLFI, SymbolicBFI, \
+    SymbolicEnergy, Mesh, NodeId, ConvertOperator, ORDER_POLICY, VTKOutput, SetHeapSize, \
+    SetTestoutFile, ngsglobals, pml, ContactBoundary, PatchwiseSolve, \
+    HCurlAMG, APhiHCurlAMG
+from .solve import Draw, \
+    SetVisualization
+from .utils import x, y, z, dx, ds, grad, Grad, curl, div, Deviator, PyId, PyTrace, \
+    PyDet, PyCross, PyCof, PyInv, PySym, PySkew, OuterProduct, PrivateSpace, Normalize, printonce
+
+from . import solvers
+from . import preconditioners
+from . import timestepping
+from .solve_implementation import Solve
+
+try:
+    from netgen.occ import unit_square, unit_cube
+except:
+    pass
+
+CF = CoefficientFunction
+
+from math import pi
+
+from builtins import sum as builtin_sum
+def sum(iterable, start=None):
+    """NGSolve sum function that uses the first element of an iterable as
+start argument if no start argument is provided."""
+    if start is not None:
+        return builtin_sum(iterable, start)
+    generator = iter(iterable)
+    try:
+        first = next(generator)
+    except StopIteration:
+        return 0
+    return builtin_sum(generator, first)
+
+from .timing import Timing
+
+# add flags docu to docstring
+def _add_flags_doc(module):
+    all_classes = module.__dict__
+    for classname in all_classes:
+        instance = all_classes[classname]
+        try:
+            flags_doc = instance.__flags_doc__()
+            if instance.__doc__ == None:
+                instance.__doc__ = ""
+            if not "Keyword arguments can be" in instance.__doc__:
+                instance.__doc__ += "\n Keyword arguments can be:\n"
+                for name in flags_doc:
+                    instance.__doc__ += name + ": " + flags_doc[name] + "\n"
+        except AttributeError:
+            pass
+
+_add_flags_doc(comp)
+
+# from . import __expr
+# BaseVector.expr = property(__expr.VecExpr)
+# BaseVector.data = property(__expr.Expr, __expr.expr_data)
+# BaseVector.__add__ = __expr.expr_add
+# BaseVector.__sub__ = __expr.expr_sub
+# BaseVector.__neg__ = __expr.expr_neg
+# BaseVector.__rmul__ = __expr.expr_rmul
+
+# BaseMatrix.expr = property(__expr.MatExpr)
+# BaseMatrix.data = property(__expr.Expr, __expr.expr_data)
+# BaseMatrix.T = property(__expr.TransExpr)
+# BaseMatrix.__mul__ = __expr.expr_mul
+# BaseMatrix.__rmul__ = __expr.expr_rmul
+# BaseMatrix.__neg__ = __expr.expr_neg
+
+def _jupyter_nbextension_paths():
+    return [
+        {
+            "section": "notebook",
+            "src": "nbextension/static",
+            "dest": "ngsolve_jupyter_widgets",
+            "require": "ngsolve_jupyter_widgets/extension",
+        }
+    ]
+
+atexit.register(solve.__Cleanup)
+

ngsolve-6.2.2506.post216.dev0.data/data/lib/python3.14/site-packages/ngsolve/_scikit_build_core_dependencies.py

@@ -0,0 +1,30 @@
+import sys
+
+
+def dynamic_metadata(field, settings):
+
+    if field != "dependencies":
+        msg = "Only the 'dependencies' field is supported"
+        raise ValueError(msg)
+
+    if settings:
+        msg = "No inline configuration is supported"
+        raise ValueError(msg)
+
+    if sys.version_info >= (3, 11):
+        import tomllib
+    else:
+        import tomli as tomllib
+
+    import importlib.metadata
+
+    config = tomllib.load(open("pyproject.toml", "rb"))
+    dependencies = config["project"].get("dependencies", [])
+
+    ngs_version = importlib.metadata.version("ngsolve")
+    dependencies = dependencies + [f"ngsolve=={ngs_version}"]
+    return dependencies
+
+
+def get_requires_for_dynamic_metadata(_settings):
+    return []

ngsolve-6.2.2506.post216.dev0.data/data/lib/python3.14/site-packages/ngsolve/bvp.py

@@ -0,0 +1,78 @@
+
+def BVP(bf, lf, gf, \
+            pre=None, pre_flags={}, \
+            solver=None, solver_flags={},
+            maxsteps=200, tol=1e-8, print=True, inverse="umfpack",
+            needsassembling=True):
+    """
+    Solve a linear boundary value problem A(u,v) = f(v)
+
+Parameters
+----------
+
+bf : BilinearForm
+  provides the matrix. 
+
+lf : LinearForm
+  provides the right hand side.
+
+gf : GridFunction
+  provides the solution vector
+
+pre : Basematrix or class or string = None
+  used if an iterative solver is used
+  can be one of 
+    * a preconditioner object
+    * a preconditioner class
+    * a preconditioner class name
+
+pre_flags : dictionary = { }
+  flags used to create preconditioner
+
+
+    """
+    from ngsolve import Projector, Preconditioner
+    from ngsolve.krylovspace import CG
+
+
+    if isinstance(pre,type):
+        pre = pre(bf, **pre_flags)
+        if not needsassembling:
+            pre.Update()
+
+    if isinstance(pre,str):
+        pre = Preconditioner(bf, pre, **pre_flags)
+        if not needsassembling:
+            pre.Update()
+
+        
+    if needsassembling:
+        bf.Assemble()
+        lf.Assemble()
+    
+    r = lf.vec.CreateVector()
+    r.data = lf.vec
+    
+    if bf.condense:
+        r.data += bf.harmonic_extension_trans * r
+
+        # zero local dofs
+        innerbits = gf.space.FreeDofs(False) & ~gf.space.FreeDofs(True)
+        Projector(innerbits, False).Project(gf.vec)
+
+    if solver:
+        inv = solver(mat=bf.mat, pre=pre, **solver_flags)
+        r.data -= bf.mat * gf.vec
+        gf.vec.data += inv * r
+                   
+    elif pre:
+        CG(mat = bf.mat, rhs = r, pre=pre, sol=gf.vec, tol=tol, maxsteps=maxsteps, initialize=False, printrates=print)
+    else:
+        inv = bf.mat.Inverse(gf.space.FreeDofs(bf.condense), inverse=inverse)
+        r.data -= bf.mat * gf.vec
+        gf.vec.data += inv * r
+
+    if bf.condense:
+        gf.vec.data += bf.harmonic_extension * gf.vec
+        gf.vec.data += bf.inner_solve * r
+            

ngsolve-6.2.2506.post216.dev0.data/data/lib/python3.14/site-packages/ngsolve/config/__init__.py

@@ -0,0 +1 @@
+from .config import *

ngsolve-6.2.2506.post216.dev0.data/data/lib/python3.14/site-packages/ngsolve/config/__main__.py

@@ -0,0 +1,4 @@
+from .config import get_cmake_dir
+
+if __name__ == '__main__':
+    print(get_cmake_dir())

ngsolve-6.2.2506.post216.dev0.data/data/lib/python3.14/site-packages/ngsolve/config/config.py

@@ -0,0 +1,60 @@
+def _cmake_to_bool(s):
+    return s.upper() not in ['', '0','FALSE','OFF','N','NO','IGNORE','NOTFOUND']
+
+is_python_package    = _cmake_to_bool("TRUE")
+
+BUILD_STUB_FILES     = _cmake_to_bool("ON")
+BUILD_UMFPACK        = _cmake_to_bool("")
+ENABLE_UNIT_TESTS    = _cmake_to_bool("OFF")
+INSTALL_DEPENDENCIES = _cmake_to_bool("OFF")
+USE_CCACHE           = _cmake_to_bool("ON")
+USE_HYPRE            = _cmake_to_bool("OFF")
+USE_LAPACK           = _cmake_to_bool("ON")
+USE_MKL              = _cmake_to_bool("ON")
+USE_MUMPS            = _cmake_to_bool("OFF")
+USE_PARDISO          = _cmake_to_bool("OFF")
+USE_UMFPACK          = _cmake_to_bool("OFF")
+
+NETGEN_DIR = "/opt/_internal/cpython-3.14.0"
+
+NGSOLVE_COMPILE_DEFINITIONS         = "HAVE_NETGEN_SOURCES;HAVE_DLFCN_H;HAVE_CXA_DEMANGLE;USE_TIMEOFDAY;TCL;LAPACK;USE_PARDISO;NGS_PYTHON"
+NGSOLVE_COMPILE_DEFINITIONS_PRIVATE = "USE_MKL"
+NGSOLVE_COMPILE_INCLUDE_DIRS        = ""
+NGSOLVE_COMPILE_OPTIONS             = "$<$<COMPILE_LANGUAGE:CXX>:-std=c++17>;-DMAX_SYS_DIM=3"
+
+NGSOLVE_INSTALL_DIR_PYTHON   = "lib/python3.14/site-packages"
+NGSOLVE_INSTALL_DIR_BIN      = "bin"
+NGSOLVE_INSTALL_DIR_LIB      = "lib/python3.14/site-packages/netgen_mesher.libs"
+NGSOLVE_INSTALL_DIR_INCLUDE  = "include/netgen"
+NGSOLVE_INSTALL_DIR_CMAKE    = "lib/cmake/ngsolve"
+NGSOLVE_INSTALL_DIR_RES      = "share"
+
+NGSOLVE_VERSION = "6.2.2506-216-g588357f34"
+NGSOLVE_VERSION_GIT = "v6.2.2506-216-g588357f34"
+NGSOLVE_VERSION_PYTHON = "6.2.2506.post216.dev0"
+
+NGSOLVE_VERSION_MAJOR = "6"
+NGSOLVE_VERSION_MINOR = "2"
+NGSOLVE_VERSION_TWEAK = "216"
+NGSOLVE_VERSION_PATCH = "2506"
+NGSOLVE_VERSION_HASH = "g588357f34"
+
+CMAKE_CXX_COMPILER           = "/opt/rh/gcc-toolset-14/root/usr/bin/c++"
+CMAKE_CUDA_COMPILER          = ""
+CMAKE_C_COMPILER             = "/opt/rh/gcc-toolset-14/root/usr/bin/cc"
+CMAKE_LINKER                 = "/opt/rh/gcc-toolset-14/root/usr/bin/ld"
+CMAKE_INSTALL_PREFIX         = "/builds/ngsolve/ngsolve/_skbuild/linux-x86_64-3.14/cmake-install"
+CMAKE_CXX_COMPILER_LAUNCHER  = "/usr/bin/ccache"
+
+version = NGSOLVE_VERSION_GIT
+
+MKL_LINK = "sdl"
+
+def get_cmake_dir():
+    import os.path as p
+    d_python = p.dirname(p.dirname(p.dirname(__file__)))
+    py_to_cmake = p.relpath(
+            NGSOLVE_INSTALL_DIR_CMAKE,
+            NGSOLVE_INSTALL_DIR_PYTHON
+            )
+    return p.normpath(p.join(d_python,py_to_cmake))

ngsolve-6.2.2506.post216.dev0.data/data/lib/python3.14/site-packages/ngsolve/demos/TensorProduct/tp_dg_1d_1d.py

@@ -0,0 +1,80 @@
+from ngsolve.TensorProductTools import *
+from ngsolve.comp import *
+from ngsolve import *
+import netgen.gui
+
+mesh1 = Mesh(SegMesh(20,0,1,periodic=True) )
+mesh2 = Mesh(SegMesh(20,0,1,periodic=True) )
+
+tpmesh = Mesh(MakeTensorProductMesh(mesh1,mesh2))
+Draw(tpmesh)
+
+n=5
+m=5
+
+fesx = L2(mesh1,order=n)
+fesy = L2(mesh2,order=m)
+
+tpfes = TensorProductFESpace([fesx,fesy])
+
+fes = L2(tpmesh,order=n)
+u = tpfes.TrialFunction()
+v = tpfes.TestFunction()
+vx = v.Operator("gradx")
+vy = v.Operator("grady")
+b = (-1)*CoefficientFunction( (0.25,0.5) )
+
+
+uin = ProlongateCoefficientFunction(IfPos((1.0-x)*(x-0.5),sin((x-0.5)*2*3.14159),0) + IfPos((x-0.0)*(0.5-x),sin((x)*2*3.14159),0) , 0 , tpfes)
+
+gradv = CoefficientFunction((vx,vy))
+
+a = BilinearForm(tpfes)
+
+n = CoefficientFunction((ProlongateCoefficientFunction(specialcf.normal(1),1,tpfes),ProlongateCoefficientFunction(specialcf.normal(1),0,tpfes)))
+bn = b*n
+
+a += SymbolicTPBFI ( (-u * b*gradv).Compile() )
+a += SymbolicTPBFI ( (bn) *IfPos(bn, u, u.Other( )) * (v-v.Other()).Compile(), VOL, skeleton=True)
+a += SymbolicTPBFI ( (bn) *IfPos(bn, u, u.Other(bnd = CoefficientFunction(uin) )) * (v).Compile(), BND, skeleton=True)
+
+
+
+u = GridFunction(tpfes)
+v = GridFunction(tpfes)
+
+uu = GridFunction(fes)
+print("Setting")
+u.Set(exp( ProlongateCoefficientFunction(-200*(x-0.4)*(x-0.4), 1, tpfes)+ ProlongateCoefficientFunction(-200*(x-0.4)*(x-0.4),0,tpfes) ) )
+print("Done")
+Transfer2StdMesh(u,uu)
+
+Draw(uu,sd=2,autoscale=False)
+
+h = u.vec.CreateVector()
+#u.vec[:] = 1.0
+print('To start the simulation type Run(n_steps)!')
+
+def Step():
+    a.Apply(u.vec,v.vec)
+    h.data = 0.00125*v.vec.data
+    tpfes.SolveM(rho=CoefficientFunction(1), vec = h)
+    u.vec.data-=h.data
+    #Redraw()
+
+def Run(nsteps):
+    count = 0
+    with TaskManager():
+        for i in range(nsteps):
+            print("Step ",i+1, "/",nsteps)
+            Step()
+            count += 1
+            if count % 1 == 0:
+                Transfer2StdMesh(u,uu)
+                count = 0
+                Redraw()
+
+Transfer2StdMesh(u,uu)
+Run(100)
+for t in Timers():
+    print(t["counts"], t["time"], t["name"])

ngsolve-6.2.2506.post216.dev0.data/data/lib/python3.14/site-packages/ngsolve/demos/TensorProduct/tp_dg_1d_2d.py

@@ -0,0 +1,73 @@
+from ngsolve.TensorProductTools import *
+from ngsolve.comp import *
+from ngsolve import *
+from netgen.geom2d import unit_square
+import netgen.gui
+
+mesh1 = Mesh(SegMesh(20,0,1))
+mesh2 = Mesh(unit_square.GenerateMesh(maxh=0.15))
+
+tpmesh = Mesh(MakeTensorProductMesh(mesh1,mesh2))
+Draw(tpmesh)
+
+n=3
+m=3
+
+fesx = L2(mesh1,order=n)
+fesy = L2(mesh2,order=m)
+tpfes = TensorProductFESpace([fesx,fesy])
+
+fes = L2(tpmesh,order=n)
+
+u = tpfes.TrialFunction()
+v = tpfes.TestFunction()
+
+vx = v.Operator("gradx")
+vy = v.Operator("grady")
+
+b = CoefficientFunction( (ProlongateCoefficientFunction(x-0.5,0,tpfes),ProlongateCoefficientFunction(0.5-x,1,tpfes),0) )
+
+uin = CoefficientFunction(0.0)
+
+
+gradv = CoefficientFunction((vx,vy))
+
+a = BilinearForm(tpfes)
+
+n = CoefficientFunction(( ProlongateCoefficientFunction(specialcf.normal(1)[0],1,tpfes),ProlongateCoefficientFunction(specialcf.normal(2)[0],0,tpfes),ProlongateCoefficientFunction(specialcf.normal(2)[1],0,tpfes)))
+bn = b*n
+
+a += SymbolicTPBFI ( -u * b*gradv )
+a += SymbolicTPBFI ( (bn) *IfPos(bn, u, u.Other(bnd = uin )) * (v-v.Other(bnd = 0.0)), VOL, skeleton=True)
+a += SymbolicTPBFI ( (bn) *IfPos(bn, u, u.Other(bnd = uin )) * (v), BND, skeleton=True)
+
+
+u = GridFunction(tpfes)
+v = GridFunction(tpfes)
+
+
+uu = GridFunction(fes)
+
+u.Set(exp(ProlongateCoefficientFunction( -70*(x-0.25)*(x-0.25),1,tpfes) + ProlongateCoefficientFunction(-70*(x-0.25)*(x-0.25)-70*(y-0.75)*(y-0.75),0,tpfes) ))
+Transfer2StdMesh(u,uu)
+Draw(uu,sd=3,autoscale=False)
+
+h = u.vec.CreateVector()
+print('To start the simulation type Run(n_steps)!')
+def Step():
+    a.Apply(u.vec,v.vec)
+    h.data = 0.001*v.vec.data
+    tpfes.SolveM(rho=CoefficientFunction(1), vec = h)
+    u.vec.data-=h.data
+    Transfer2StdMesh(u,uu)
+    Redraw()
+
+def Run(nsteps):
+    with TaskManager():
+        for i in range(nsteps):
+            print("Step ",i+1, "/",nsteps)
+            Step()
+
+#Run(100)
+for t in Timers():
+    print(t["counts"], t["time"], t["name"])