# Working with CoefficientFunctions¶

A CoefficientFunction is a function which can be evaluated on a mesh, and may be used to provide the coefficient or a right-hand-side to the variational formulation. Because typical finite element procedures iterate over elements, and map integration points from a reference element to a physical element, the evaluation of a CoefficientFunction requires a mapped integration point. The mapped integration point contains the coordinate, as well as the Jacobian, but also element number and region index. This allows the efficient evaluation of a wide class of functions needed for finite element computations.

class ngsolve.CoefficientFunction

A CoefficientFunction (CF) is some function defined on a mesh. Examples are coordinates x, y, z, domain-wise constants, solution-fields, ... CFs can be combined by mathematical operations (+,-,sin(), ...) to form new CFs Parameters:

val : can be one of the following:

scalar (float or complex):

Creates a constant CoefficientFunction with value val

tuple of scalars or CoefficientFunctions:

Creates a vector or matrix valued CoefficientFunction, use dims=(h,w) for matrix valued CF

list of scalars or CoefficientFunctions:

Creates a domain-wise CF, use with generator expressions and mesh.GetMaterials() and mesh.GetBoundaries()

## Basic Coefficient Functions¶

Python objects implicitly convertible to float or Complex are implicitly converted to CoefficientFunction if needed. The Cartesian coordinates x, y, and z are pre-defined coordinate coefficient functions:

```f = LinearForm(V)
f += SymbolicLFI( x * V.TestFunction())
```

A CoefficientFunction initialized with a list stores one value per region, depending where the CoefficientFunction is used this is a domain or boundary region. Here one usually uses generator expressions in combination with `mesh.GetMaterials()` and `mesh.GetBoundaries()`:

```alpha_d = {"air" : 1, "box" : 100}
alpha = CoefficientFunction([alpha_d[mat] for mat in mesh.GetMaterials()])
```

A CoefficientFunction initialized with a tuple gives a vector coefficient function. Components of the coefficient function can be accessed by the bracket operator:

```vec_cf = CoefficientFunction( (fx,fy) )  # Creates a vector CF
fx_again = vec_cf[0]                     # Creates a scalar CF from the first component
```

A matrix valued CF can be created with the additional dims argument:

```mat_cf = CoefficientFunction((f11,f12,f21,f22),dims=(2,2))
```

## ProxyFunctions¶

The finite element spaces provide proxy placeholder functions for Symbolic Integrators when assembling the system matrices the proxy functions are replaced with the FEM basis functions.

FESpace.TrialFunction(self: ngsolve.comp.FESpace) object

Return a proxy to be used as a trialfunction in Symbolic Integrators

FESpace.TestFunction(self: ngsolve.comp.FESpace) object

Return a proxy to be used as a testfunction for Symbolic Integrators

## Operations on CoefficientFunctions¶

CoefficientFunctions can be combined with algebraic operations (+,-,*,/,**). Math functions are available as well for CoefficientFunctions: sin, cos, tan, exp, log, atan, sqrt, Conj.

## Special CoefficientFunctions¶

NGSolve provides special coefficient functions needed for finite element computations. Special coefficient functions are mesh dependent.

You can get the normal vector on an interface with

specialcf.normal = <bound method PyCapsule.normal of <ngsolve.fem.SpecialCFCreator object>>

this can be used in discontinuous Galerkin methods.

The tangential vector can be obtained in the same way:

specialcf.tangential = <bound method PyCapsule.tangential of <ngsolve.fem.SpecialCFCreator object>>

The local mesh size can be obtained by a coefficient function as well:

specialcf.mesh_size = <ngsolve.fem.CoefficientFunction object>

This has application i.e. in `hybrid DG methods`.

### IfPos¶

The function IfPos provides CoefficientFunctions depending on some condition:

ngsolve.IfPos(*args, **kwargs)

1. IfPos(c1: ngfem::CoefficientFunction, then_obj: object, else_obj: object) -> ngfem::CoefficientFunction

Returns new CoefficientFunction with values then_obj if c1 is positive and else_obj else.

Parameters:

c1ngsolve.CoefficientFunction

Indicator function

then_objobject

Values of new CF if c1 is positive, object must be implicitly convertible to ngsolve.CoefficientFunction. See help(`CoefficientFunction` ) for information.

else_objobject

Values of new CF if c1 is not positive, object must be implicitly convertible to ngsolve.CoefficientFunction. See help(`CoefficientFunction` ) for information.

1. IfPos(arg0: numpy.ndarray[numpy.float64], arg1: numpy.ndarray[numpy.float64], arg2: numpy.ndarray[numpy.float64]) -> object

### Parameter CoefficientFunction¶

If you want a CoefficientFunction with a variable parameter, instead of using a new BilinearForm every time you can use a Parameter CF. The parameter can be modified with the Set method and when assembling the BilinearForm again, the updated parameter is used.

class ngsolve.Parameter

CoefficientFunction with a modifiable value

Parameters:

valuefloat

Parameter value

Get(self: ngsolve.fem.Parameter) float

return parameter value

Set(self: ngsolve.fem.Parameter, value: float) None

Modify parameter value.

Parameters:

valuedouble

input scalar

### BSpline CoefficientFunction¶

You can create a BSpline as a CoefficientFunction as well. BSplines are differentiable and integrable:

class ngsolve.BSpline

BSpline of arbitrary order

Parameters:

orderint

order of the BSpline

knotslist

list of float

valslist

list of float

Differentiate(self: ngsolve.fem.BSpline)

Differentiate the BSpline

Integrate(self: ngsolve.fem.BSpline)

Integrate the BSpline

## Compiling a CoefficientFunctions¶

CoefficientFunction.Compile(self: ngsolve.fem.CoefficientFunction, realcompile: bool = False, maxderiv: int = 2, wait: bool = False, keep_files: bool = False)

Compile list of individual steps, experimental improvement for deep trees

Parameters:

realcompilebool

True -> Compile to C++ code

maxderivint

input maximal derivative

waitbool

True -> Waits until the previous Compile call is finished before start compiling

keep_filesbool

True -> Keep temporary files

## Evaluating CoefficientFunctions¶

Sometimes it can be useful to evaluate a CoefficientFunction. Since some CoefficientFunctions are only defined on the mesh (like a GridFunction) this can only be done with information from the mesh. For this we request a mapped integration point from the mesh and plug it into the CoefficientFunction:

```>>> mip = mesh(0.2,0.4)
>>> cf = x*x*y
>>> cf(mip)
0.016000000000000004
```