# FunctionΒΆ

Type: | string |
---|---|

Range: | [] |

Default: | -/- |

Appearance: | simple |

Excludes: | Expression |

Used in combination with Module to specify the python function containing the density field definition.

In the most simple case a Python module is a `.py`

-file which contains one or several python function definition. In this case the name of the module is simply the file name without its `.py`

suffix. The parameter `Function`

is used to pick out the desired function.

The so specified Python function must return a scalar and must accept a single argument which is a dictionary containing the parameters as defined by the Parameter sections.

The syntax is identical to a Python based definition of a source field, see for example the section Function for the definition of an electric field intensity.

As a practical example we want to integrate the electric field energy density of a time-harmonic electric field intensity :

This density field has two field parameters, namely the electric field intensity and the complex permittivity tensor .

Tip

It is easier to define this simple example as an inline Python expression as shown in Expression.

Assuming that the respective Python implementation is contained in module `PythonTensorFieldLibrary`

with function name `ElectricEnergyDensity`

, the JCM-syntax looks like this:

```
DensityIntegration {
FieldBagPath = ...
OutputFileName = ...
Python {
IntegralName = "ElectricEnergy"
Module = "PythonTensorFieldLibrary"
Function = "ElectricEnergyDensity"
Parameter {
Name = "D"
FieldValue {
Quantity = ElectricFluxDensity
}
}
Parameter {
Name = "E"
FieldValue {
Quantity = ElectricFieldStrength
}
}
}
}
```

In the above, the tag `FieldBagPath`

defines the underlying fieldbag which supplies the meshing for integration. When the underlying fieldbag contains more than one electric field intensities (tagged by `ElectricFieldStrength`

), `JCMsolve`

computes all energies separately.

The used Python function may have the following form:

```
from numpy import *
def ElectricEnergyDensity(parameters):
D = parameters['D'] # retrieving the D-field vector
E = parameters['E'] # retrieving the E-field vector
return 0.25*dot(D.conj().T, E)
```

As a second example, we want to compute overlap integrals of the form

This example involves two fieldbags: One fieldbag delivers the , the other the electric flux density . Surely, the two fieldbags may coincide. The JCM input snippet for this example looks like this:

```
DensityIntegration {
FieldBagPath = ... # path to first fieldbag
OutputFileName = ...
Python {
Module = "PythonTensorFieldLibrary"
Function = "ElectricEnergyDensity"
Parameter {
Name = "D"
FieldValue {
Quantity = ElectricFluxDensity
IntegralIndex =1
}
}
Parameter {
Name = "E"
FieldValue {
FieldBagPath = ... # path to second fieldbag
Quantity = ElectricFieldStrength
IntegralIndex =2
}
}
}
}
```

The Python code is identical to the previous example. However, the field index of the -field parameter runs with the first integral index , where as the field index of the VField{E}-fields runs with the second integral index . This way the overlap integrals of all -fields in the first fieldbag with all -fields in the second fieldbag are computed.

As a practical example we want to compute the electromagnetic energy fluxes through domain interfaces of a time-harmonic electromagnetic field. The flux density is the Poynting vector:

This flux density field has two field parameters, namely the electric field intensity and the magnetic field intensity .

Tip

It is easier to define this simple example as an inline Python expression as shown in Expression.

Assuming that the respective Python implementation is contained in module `PythonTensorFieldLibrary`

with function name `PoyntingVector`

, the JCM-syntax looks like this:

The post-process may be defined as follows:

DensityIntegration { FieldBagPath = ... OutputFileName = ... InterfaceType = ... Module = "PythonTensorFieldLibrary" Function = "PoyntingVector" Python { IntegralName = "ElectromagneticEnergyFlux" Parameter { Name = "E" FieldValue { Quantity = ElectricFieldStrength } } Parameter { Name = "H" FieldValue { Quantity = MagneticFieldStrength } } } }In the above, the tag

`FieldBagPath`

defines the underlying fieldbag which supplies the meshing for integration. When the underlying fieldbag contains more than one electromagnetic fields,`JCMsolve`

computes all fluxes separately. When choosing`InterfaceType=ExteriorDomain`

the scattered fields and are passed on the interior-exterior domain interfaces.The used Python function may have the following form:

from numpy import * def ElectricEnergyDensity(parameter): E = parameter['E'] # retrieving the E-field vector H = parameter['E'] # retrieving the H-field vector return 0.5*cross(E, H)As a second example, we want to compute overlap integrals of the form

on the cross-section domains of a two-dimensional problem with an infinite -direction. This requires to set

`InterfaceType=CrossSection`

.This example involves two fieldbags: One fieldbag delivers the electric field , the other the magnetic field . The two fieldbags may coincide. The JCM input snippet for this example looks like this:

DensityIntegration { FieldBagPath = ... # path to first fieldbag OutputFileName = ... InterfaceType = CrossSection Python { IntegralName = "OverlapCrossSectionEnergyFlux" Module = "PythonTensorFieldLibrary" Function = "PoyntingVector" Parameter { Name = "E" FieldValue { Quantity = ElectricFieldStrength } } Parameter { Name = "H" FieldValue { FieldBagPath = ... # path to second fieldbag Quantity = MagneticFieldStrength } } } }The Python code is identical to the previous example. However, the field index of the -field parameter runs with the first integral index , where as the field index of the -fields runs with the second integral index . This way the overlap flux integrals of all -fields in the first fieldbag with all -fields in the second fieldbag are computed.