XML reference

This page contains the full reference of the XML configuration of the preCICE library, containing the tag structure as well as attributes and their types and values.

precice-configuration

Main tag containing preCICE configuration.

Example:

<precice-configuration experimental="false" allow-remeshing="false" wait-in-finalize="false">
  <log enabled="true">
    ...
  </log>
  <profiling mode="fundamental" flush-every="50" directory="." synchronize="false"/>
  <data:scalar name="{string}" waveform-degree="1" lower-bound="-inf" upper-bound="inf"/>
  <mesh name="{string}" dimensions="{integer}">
    ...
  </mesh>
  <m2n:sockets port="0" network="lo" exchange-directory="." acceptor="{string}" connector="{string}" enforce-gather-scatter="false" use-two-level-initialization="false"/>
  <participant name="{string}">
    ...
  </participant>
  <coupling-scheme:serial-explicit>
    ...
  </coupling-scheme:serial-explicit>
</precice-configuration>
AttributeTypeDescriptionDefaultOptions
experimentalbooleanEnable experimental features.falsenone
allow-remeshingbooleanEnable experimental remeshing feature, requires experimental to be true.falsenone
wait-in-finalizebooleanConnected participants wait for each other in finalize, which can be helpful in SLURM sessions.falsenone

Valid Subtags:

log

Configures logging sinks based on Boost log.

Example:

<log enabled="true">
  <sink type="stream" output="stdout" format="(%Rank%) %TimeStamp(format="%H:%M:%S")% [%Module%]:%Line% in %Function%: %ColorizedSeverity%%Message%" filter="(%Severity% > debug) and not ((%Severity% = info) and (%Rank% != 0))" enabled="true"/>
</log>
AttributeTypeDescriptionDefaultOptions
enabledbooleanEnables the creation of log sinks. Disable sinks if you prefer to handle preCICE logs in your application using boost.log.truenone

Valid Subtags:

sink

Contains the configuration of a single log sink, which allows fine grained control of what to log where. Available attributes in filter and format strings are %TimeStamp%, %Runtime%, %Severity%, %ColorizedSeverity%, %File%, %Line%, %Function%, %Module%, %Rank%, and %Participant%. The boolean attribute %preCICE% is true for all log entries originating from preCICE.

Example:

<sink type="stream" output="stdout" format="(%Rank%) %TimeStamp(format="%H:%M:%S")% [%Module%]:%Line% in %Function%: %ColorizedSeverity%%Message%" filter="(%Severity% > debug) and not ((%Severity% = info) and (%Rank% != 0))" enabled="true"/>
AttributeTypeDescriptionDefaultOptions
typestringThe type of sink.streamstream, file
outputstringDepends on the type of the sink. For streams, this can be stdout or stderr. For files, this is the filename.stdoutnone
formatstringBoost Log Format String(%Rank%) %TimeStamp(format="%H:%M:%S")% [%Module%]:%Line% in %Function%: %ColorizedSeverity%%Message%none
filterstringBoost Log Filter String(%Severity% > debug) and not ((%Severity% = info) and (%Rank% != 0))none
enabledbooleanEnables the sinktruenone

profiling

Allows configuring the profiling functionality of preCICE.

Example:

<profiling mode="fundamental" flush-every="50" directory="." synchronize="false"/>
AttributeTypeDescriptionDefaultOptions
modestringOperational modes of the profiling. “fundamental” will only write fundamental steering events. “api” will write events of the complete API. “all” writes all events.fundamentalall, api, fundamental, off
flush-everyintegerSet the amount of event records that should be kept in memory before flushing them to file. One event consists out of multiple records. 0 keeps all records in memory and writes them at the end of the program, useful for slower network filesystems. 1 writes records directly to the file, useful to get profiling data despite program crashes. Settings greater than 1 keep records in memory and write them to file in blocks, which is recommended.50none
directorystringDirectory to use as a root directory to write the events to. Events will be written to <directory>/precice-profiling/.none
synchronizebooleanEnables additional inter- and intra-participant synchronization points. This avoids measuring blocking time for communication and other collective operations.falsenone

data:scalar

Defines a scalar data set to be assigned to meshes. Lower and upper bound of the data can be specified to prevent acceleration methods of IQN family violating the physical value range.

Example:

<data:scalar name="{string}" waveform-degree="1" lower-bound="-inf" upper-bound="inf"/>
AttributeTypeDescriptionDefaultOptions
namestringUnique name for the data set.nonenone
waveform-degreeintegerPolynomial degree of waveform that is used for time interpolation.1none
lower-boundfloatLower bound for the scalar data. Example is 0 for temperature in Kelvin.-infnone
upper-boundfloatUpper bound for the scalar data. Example is 1 for volumetric phase fractioninfnone

data:vector

Defines a vector data set to be assigned to meshes. The number of components of each data entry depends on the spatial dimensions of the mesh.Lower and upper bound for each component can be specified to prevent acceleration methods of IQN family violating the physical value range.

Example:

<data:vector name="{string}" waveform-degree="1" lower-bound-x="-inf" lower-bound-y="-inf" lower-bound-z="-inf" upper-bound-x="inf" upper-bound-y="inf" upper-bound-z="inf"/>
AttributeTypeDescriptionDefaultOptions
namestringUnique name for the data set.nonenone
waveform-degreeintegerPolynomial degree of waveform that is used for time interpolation.1none
lower-bound-xfloatLower bound for the x-component of the vector data.-infnone
lower-bound-yfloatLower bound for the y-component of the vector data.-infnone
lower-bound-zfloatLower bound for the z-component of the vector data.-infnone
upper-bound-xfloatUpper bound for the x-component of the vector data.infnone
upper-bound-yfloatUpper bound for the y-component of the vector data.infnone
upper-bound-zfloatUpper bound for the z-component of the vector data.infnone

mesh

Surface mesh consisting of vertices and optional connectivity information. The vertices of a mesh can carry data, configured by tags . The mesh coordinates have to be defined by a participant (see tag ).

Example:

<mesh name="{string}" dimensions="{integer}">
  <use-data name="{string}"/>
</mesh>
AttributeTypeDescriptionDefaultOptions
namestringUnique name for the mesh.nonenone
dimensionsintegerSpatial dimensions of meshnone2, 3

Valid Subtags:

use-data

Assigns a before defined data set (see tag ) to the mesh.

Example:

<use-data name="{string}"/>
AttributeTypeDescriptionDefaultOptions
namestringName of the data set.nonenone

m2n:sockets

Communication via Sockets.

Example:

<m2n:sockets port="0" network="lo" exchange-directory="." acceptor="{string}" connector="{string}" enforce-gather-scatter="false" use-two-level-initialization="false"/>
AttributeTypeDescriptionDefaultOptions
portintegerPort number (16-bit unsigned integer) to be used for socket communication. The default is “0”, what means that the OS will dynamically search for a free port (if at least one exists) and bind it automatically.0none
networkstringInterface name to be used for socket communication. Default is the canonical name of the loopback interface of your platform. Might be different on supercomputing systems, e.g. “ib0” for the InfiniBand on SuperMUC.lonone
exchange-directorystringDirectory where connection information is exchanged. By default, the directory of startup is chosen, and both solvers have to be started in the same directory..none
acceptorstringFirst participant name involved in communication. For performance reasons, we recommend to use the participant with less ranks at the coupling interface as “acceptor” in the m2n communication.nonenone
connectorstringSecond participant name involved in communication.nonenone
enforce-gather-scatterbooleanEnforce the distributed communication to a gather-scatter scheme. Only recommended for trouble shooting.falsenone
use-two-level-initializationbooleanUse a two-level initialization scheme. Recommended for large parallel runs (>5000 MPI ranks).falsenone

m2n:mpi-multiple-ports

Communication via MPI with startup in separated communication spaces, using multiple communicators.

Example:

<m2n:mpi-multiple-ports exchange-directory="." acceptor="{string}" connector="{string}" enforce-gather-scatter="false" use-two-level-initialization="false"/>
AttributeTypeDescriptionDefaultOptions
exchange-directorystringDirectory where connection information is exchanged. By default, the directory of startup is chosen, and both solvers have to be started in the same directory..none
acceptorstringFirst participant name involved in communication. For performance reasons, we recommend to use the participant with less ranks at the coupling interface as “acceptor” in the m2n communication.nonenone
connectorstringSecond participant name involved in communication.nonenone
enforce-gather-scatterbooleanEnforce the distributed communication to a gather-scatter scheme. Only recommended for trouble shooting.falsenone
use-two-level-initializationbooleanUse a two-level initialization scheme. Recommended for large parallel runs (>5000 MPI ranks).falsenone

m2n:mpi

Communication via MPI with startup in separated communication spaces, using a single communicator

Example:

<m2n:mpi exchange-directory="." acceptor="{string}" connector="{string}" enforce-gather-scatter="false" use-two-level-initialization="false"/>
AttributeTypeDescriptionDefaultOptions
exchange-directorystringDirectory where connection information is exchanged. By default, the directory of startup is chosen, and both solvers have to be started in the same directory..none
acceptorstringFirst participant name involved in communication. For performance reasons, we recommend to use the participant with less ranks at the coupling interface as “acceptor” in the m2n communication.nonenone
connectorstringSecond participant name involved in communication.nonenone
enforce-gather-scatterbooleanEnforce the distributed communication to a gather-scatter scheme. Only recommended for trouble shooting.falsenone
use-two-level-initializationbooleanUse a two-level initialization scheme. Recommended for large parallel runs (>5000 MPI ranks).falsenone

participant

Represents one solver using preCICE. At least two participants have to be defined.

Example:

<participant name="{string}">
  <write-data name="{string}" mesh="{string}"/>
  <read-data name="{string}" mesh="{string}"/>
  <mapping:nearest-neighbor from="" to="" direction="{string}" constraint="{string}"/>
  <action:multiply-by-area timing="{string}" mesh="{string}">
    ...
  </action:multiply-by-area>
  <export:vtk directory="." every-n-time-windows="1" every-iteration="false" update-series="false"/>
  <watch-point name="{string}" mesh="{string}" coordinate="{vector}"/>
  <watch-integral name="{string}" mesh="{string}" scale-with-connectivity="{boolean}"/>
  <provide-mesh name="{string}"/>
  <receive-mesh name="{string}" api-access="false" direct-access="false" geometric-filter="on-secondary-ranks" from="{string}" safety-factor="0.5"/>
  <intra-comm:sockets port="0" network="lo" exchange-directory="."/>
</participant>
AttributeTypeDescriptionDefaultOptions
namestringName of the participant. Has to match the name given on construction of the precice::Participant object used by the participant.nonenone

Valid Subtags:

write-data

Sets data to be written by the participant to preCICE. Data is defined by using the tag.

Example:

<write-data name="{string}" mesh="{string}"/>
AttributeTypeDescriptionDefaultOptions
namestringName of the data.nonenone
meshstringMesh the data belongs to. If data should be read/written to several meshes, this has to be specified separately for each mesh.nonenone

read-data

Sets data to be read by the participant from preCICE. Data is defined by using the tag.

Example:

<read-data name="{string}" mesh="{string}"/>
AttributeTypeDescriptionDefaultOptions
namestringName of the data.nonenone
meshstringMesh the data belongs to. If data should be read/written to several meshes, this has to be specified separately for each mesh.nonenone

mapping:nearest-neighbor

Nearest-neighbour mapping which uses a rstar-spatial index tree to index meshes and run nearest-neighbour queries.

Example:

<mapping:nearest-neighbor from="" to="" direction="{string}" constraint="{string}"/>
AttributeTypeDescriptionDefaultOptions
fromstringThe mesh to map the data from. The default name is an empty mesh name, which is only valid for a just-in-time mapping (using the API functions “writeAndMapData” or “mapAndReadData”).``none
tostringThe mesh to map the data to. The default name is an empty mesh name, which is only valid for a just-in-time mapping (using the API functions “writeAndMapData” or “mapAndReadData”).``none
directionstringWrite mappings map written data prior to communication, thus in the same participant who writes the data. Read mappings map received data after communication, thus in the same participant who reads the data.nonewrite, read
constraintstringUse conservative to conserve the nodal sum of the data over the interface (needed e.g. for force mapping). Use consistent for normalized quantities such as temperature or pressure. Use scaled-consistent-surface or scaled-consistent-volume for normalized quantities where conservation of integral values (surface or volume) is needed (e.g. velocities when the mass flow rate needs to be conserved). Mesh connectivity is required to use scaled-consistent.noneconservative, consistent, scaled-consistent-surface, scaled-consistent-volume

mapping:nearest-projection

Nearest-projection mapping which uses a rstar-spatial index tree to index meshes and locate the nearest projections.

Example:

<mapping:nearest-projection from="" to="" direction="{string}" constraint="{string}"/>
AttributeTypeDescriptionDefaultOptions
fromstringThe mesh to map the data from. The default name is an empty mesh name, which is only valid for a just-in-time mapping (using the API functions “writeAndMapData” or “mapAndReadData”).``none
tostringThe mesh to map the data to. The default name is an empty mesh name, which is only valid for a just-in-time mapping (using the API functions “writeAndMapData” or “mapAndReadData”).``none
directionstringWrite mappings map written data prior to communication, thus in the same participant who writes the data. Read mappings map received data after communication, thus in the same participant who reads the data.nonewrite, read
constraintstringUse conservative to conserve the nodal sum of the data over the interface (needed e.g. for force mapping). Use consistent for normalized quantities such as temperature or pressure. Use scaled-consistent-surface or scaled-consistent-volume for normalized quantities where conservation of integral values (surface or volume) is needed (e.g. velocities when the mass flow rate needs to be conserved). Mesh connectivity is required to use scaled-consistent.noneconservative, consistent, scaled-consistent-surface, scaled-consistent-volume

mapping:nearest-neighbor-gradient

Nearest-neighbor-gradient mapping which uses nearest-neighbor mapping with an additional linear approximation using gradient data.

Example:

<mapping:nearest-neighbor-gradient from="" to="" direction="{string}" constraint="{string}"/>
AttributeTypeDescriptionDefaultOptions
fromstringThe mesh to map the data from. The default name is an empty mesh name, which is only valid for a just-in-time mapping (using the API functions “writeAndMapData” or “mapAndReadData”).``none
tostringThe mesh to map the data to. The default name is an empty mesh name, which is only valid for a just-in-time mapping (using the API functions “writeAndMapData” or “mapAndReadData”).``none
directionstringWrite mappings map written data prior to communication, thus in the same participant who writes the data. Read mappings map received data after communication, thus in the same participant who reads the data.nonewrite, read
constraintstringUse conservative to conserve the nodal sum of the data over the interface (needed e.g. for force mapping). Use consistent for normalized quantities such as temperature or pressure. Use scaled-consistent-surface or scaled-consistent-volume for normalized quantities where conservation of integral values (surface or volume) is needed (e.g. velocities when the mass flow rate needs to be conserved). Mesh connectivity is required to use scaled-consistent.noneconservative, consistent, scaled-consistent-surface, scaled-consistent-volume

mapping:linear-cell-interpolation

Linear cell interpolation mapping which uses a rstar-spatial index tree to index meshes and locate the nearest cell. Only supports 2D meshes.

Example:

<mapping:linear-cell-interpolation from="" to="" direction="{string}" constraint="{string}"/>
AttributeTypeDescriptionDefaultOptions
fromstringThe mesh to map the data from. The default name is an empty mesh name, which is only valid for a just-in-time mapping (using the API functions “writeAndMapData” or “mapAndReadData”).``none
tostringThe mesh to map the data to. The default name is an empty mesh name, which is only valid for a just-in-time mapping (using the API functions “writeAndMapData” or “mapAndReadData”).``none
directionstringWrite mappings map written data prior to communication, thus in the same participant who writes the data. Read mappings map received data after communication, thus in the same participant who reads the data.nonewrite, read
constraintstringUse conservative to conserve the nodal sum of the data over the interface (needed e.g. for force mapping). Use consistent for normalized quantities such as temperature or pressure. Use scaled-consistent-surface or scaled-consistent-volume for normalized quantities where conservation of integral values (surface or volume) is needed (e.g. velocities when the mass flow rate needs to be conserved). Mesh connectivity is required to use scaled-consistent.noneconservative, consistent, scaled-consistent-surface, scaled-consistent-volume

mapping:rbf-global-iterative

Radial-basis-function mapping using an iterative solver with a distributed parallelism.

Example:

<mapping:rbf-global-iterative from="" to="" direction="{string}" constraint="{string}" polynomial="separate" x-dead="false" y-dead="false" z-dead="false" solver-rtol="1e-09">
  <executor:cpu/>
  <basis-function:compact-polynomial-c0 support-radius="{float}"/>
</mapping:rbf-global-iterative>
AttributeTypeDescriptionDefaultOptions
fromstringThe mesh to map the data from. The default name is an empty mesh name, which is only valid for a just-in-time mapping (using the API functions “writeAndMapData” or “mapAndReadData”).``none
tostringThe mesh to map the data to. The default name is an empty mesh name, which is only valid for a just-in-time mapping (using the API functions “writeAndMapData” or “mapAndReadData”).``none
directionstringWrite mappings map written data prior to communication, thus in the same participant who writes the data. Read mappings map received data after communication, thus in the same participant who reads the data.nonewrite, read
constraintstringUse conservative to conserve the nodal sum of the data over the interface (needed e.g. for force mapping). Use consistent for normalized quantities such as temperature or pressure. Use scaled-consistent-surface or scaled-consistent-volume for normalized quantities where conservation of integral values (surface or volume) is needed (e.g. velocities when the mass flow rate needs to be conserved). Mesh connectivity is required to use scaled-consistent.noneconservative, consistent, scaled-consistent-surface, scaled-consistent-volume
polynomialstringToggles use of the global polynomialseparateon, off, separate
x-deadbooleanIf set to true, the x axis will be ignored for the mappingfalsenone
y-deadbooleanIf set to true, the y axis will be ignored for the mappingfalsenone
z-deadbooleanIf set to true, the z axis will be ignored for the mappingfalsenone
solver-rtolfloatSolver relative tolerance for convergence1e-09none

Valid Subtags:

executor:cpu

The default executor relying on PETSc, which uses CPUs and distributed memory parallelism via MPI.

Example:

<executor:cpu/>

executor:cuda

Cuda (Nvidia) executor, which uses Ginkgo with a gather-scatter parallelism.

Example:

<executor:cuda gpu-device-id="0"/>
AttributeTypeDescriptionDefaultOptions
gpu-device-idstringSetting of the GPU device: Set “auto” to assign GPUs to each MPI rank in a round robin fashion or specify a number between 0 and the number of available GPUs-1 to assign all MPI ranks to one GPU device with the given ID.0none

executor:hip

Hip (AMD/Nvidia) executor, which uses hipSolver with a gather-scatter parallelism.

Example:

<executor:hip gpu-device-id="0"/>
AttributeTypeDescriptionDefaultOptions
gpu-device-idstringSetting of the GPU device: Set “auto” to assign GPUs to each MPI rank in a round robin fashion or specify a number between 0 and the number of available GPUs-1 to assign all MPI ranks to one GPU device with the given ID.0none

executor:openmp

OpenMP executor, which uses Ginkgo with a gather-scatter parallelism.

Example:

<executor:openmp n-threads="0"/>
AttributeTypeDescriptionDefaultOptions
n-threadsintegerSpecifies the number of threads for the OpenMP executor that should be used for the Ginkgo OpenMP backend. If a value of “0” is set, preCICE doesn’t set the number of threads and the default behavior of OpenMP applies.0none

basis-function:compact-polynomial-c0

Wendland C0 function

Example:

<basis-function:compact-polynomial-c0 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:compact-polynomial-c2

Wendland C2 function

Example:

<basis-function:compact-polynomial-c2 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:compact-polynomial-c4

Wendland C4 function

Example:

<basis-function:compact-polynomial-c4 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:compact-polynomial-c6

Wendland C6 function

Example:

<basis-function:compact-polynomial-c6 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:compact-polynomial-c8

Wendland C8 function

Example:

<basis-function:compact-polynomial-c8 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:compact-tps-c2

Compact thin-plate-spline C2

Example:

<basis-function:compact-tps-c2 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:multiquadrics

Multiquadrics

Example:

<basis-function:multiquadrics shape-parameter="{float}"/>
AttributeTypeDescriptionDefaultOptions
shape-parameterfloatSpecific shape parameter for RBF basis function.nonenone

basis-function:inverse-multiquadrics

Inverse multiquadrics

Example:

<basis-function:inverse-multiquadrics shape-parameter="{float}"/>
AttributeTypeDescriptionDefaultOptions
shape-parameterfloatSpecific shape parameter for RBF basis function.nonenone

basis-function:gaussian

Gaussian basis function accepting a support radius or a shape parameter.

Example:

<basis-function:gaussian shape-parameter="nan" support-radius="nan"/>
AttributeTypeDescriptionDefaultOptions
shape-parameterfloatSpecific shape parameter for RBF basis function.nannone
support-radiusfloatSupport radius of each RBF basis function (global choice).nannone

basis-function:thin-plate-splines

Thin-plate-splines

Example:

<basis-function:thin-plate-splines/>

basis-function:volume-splines

Volume splines

Example:

<basis-function:volume-splines/>

mapping:rbf-global-direct

Radial-basis-function mapping using a direct solver with a gather-scatter parallelism.

Example:

<mapping:rbf-global-direct from="" to="" direction="{string}" constraint="{string}" polynomial="separate" x-dead="false" y-dead="false" z-dead="false">
  <executor:cpu/>
  <basis-function:compact-polynomial-c0 support-radius="{float}"/>
</mapping:rbf-global-direct>
AttributeTypeDescriptionDefaultOptions
fromstringThe mesh to map the data from. The default name is an empty mesh name, which is only valid for a just-in-time mapping (using the API functions “writeAndMapData” or “mapAndReadData”).``none
tostringThe mesh to map the data to. The default name is an empty mesh name, which is only valid for a just-in-time mapping (using the API functions “writeAndMapData” or “mapAndReadData”).``none
directionstringWrite mappings map written data prior to communication, thus in the same participant who writes the data. Read mappings map received data after communication, thus in the same participant who reads the data.nonewrite, read
constraintstringUse conservative to conserve the nodal sum of the data over the interface (needed e.g. for force mapping). Use consistent for normalized quantities such as temperature or pressure. Use scaled-consistent-surface or scaled-consistent-volume for normalized quantities where conservation of integral values (surface or volume) is needed (e.g. velocities when the mass flow rate needs to be conserved). Mesh connectivity is required to use scaled-consistent.noneconservative, consistent, scaled-consistent-surface, scaled-consistent-volume
polynomialstringToggles use of the global polynomialseparateon, off, separate
x-deadbooleanIf set to true, the x axis will be ignored for the mappingfalsenone
y-deadbooleanIf set to true, the y axis will be ignored for the mappingfalsenone
z-deadbooleanIf set to true, the z axis will be ignored for the mappingfalsenone

Valid Subtags:

executor:cpu

The default executor, which uses a single-core CPU with a gather-scatter parallelism.

Example:

<executor:cpu/>

executor:cuda

Cuda (Nvidia) executor, which uses cuSolver/Ginkgo and a direct QR decomposition with a gather-scatter parallelism.

Example:

<executor:cuda gpu-device-id="0"/>
AttributeTypeDescriptionDefaultOptions
gpu-device-idstringSetting of the GPU device: Set “auto” to assign GPUs to each MPI rank in a round robin fashion or specify a number between 0 and the number of available GPUs-1 to assign all MPI ranks to one GPU device with the given ID.0none

executor:hip

Hip (AMD/Nvidia) executor, which uses hipSolver/Ginkgo and a direct QR decomposition with a gather-scatter parallelism.

Example:

<executor:hip gpu-device-id="0"/>
AttributeTypeDescriptionDefaultOptions
gpu-device-idstringSetting of the GPU device: Set “auto” to assign GPUs to each MPI rank in a round robin fashion or specify a number between 0 and the number of available GPUs-1 to assign all MPI ranks to one GPU device with the given ID.0none

basis-function:compact-polynomial-c0

Wendland C0 function

Example:

<basis-function:compact-polynomial-c0 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:compact-polynomial-c2

Wendland C2 function

Example:

<basis-function:compact-polynomial-c2 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:compact-polynomial-c4

Wendland C4 function

Example:

<basis-function:compact-polynomial-c4 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:compact-polynomial-c6

Wendland C6 function

Example:

<basis-function:compact-polynomial-c6 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:compact-polynomial-c8

Wendland C8 function

Example:

<basis-function:compact-polynomial-c8 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:compact-tps-c2

Compact thin-plate-spline C2

Example:

<basis-function:compact-tps-c2 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:multiquadrics

Multiquadrics

Example:

<basis-function:multiquadrics shape-parameter="{float}"/>
AttributeTypeDescriptionDefaultOptions
shape-parameterfloatSpecific shape parameter for RBF basis function.nonenone

basis-function:inverse-multiquadrics

Inverse multiquadrics

Example:

<basis-function:inverse-multiquadrics shape-parameter="{float}"/>
AttributeTypeDescriptionDefaultOptions
shape-parameterfloatSpecific shape parameter for RBF basis function.nonenone

basis-function:gaussian

Gaussian basis function accepting a support radius or a shape parameter.

Example:

<basis-function:gaussian shape-parameter="nan" support-radius="nan"/>
AttributeTypeDescriptionDefaultOptions
shape-parameterfloatSpecific shape parameter for RBF basis function.nannone
support-radiusfloatSupport radius of each RBF basis function (global choice).nannone

basis-function:thin-plate-splines

Thin-plate-splines

Example:

<basis-function:thin-plate-splines/>

basis-function:volume-splines

Volume splines

Example:

<basis-function:volume-splines/>

mapping:rbf-pum-direct

Radial-basis-function mapping using a partition of unity method, which supports a distributed parallelism.

Example:

<mapping:rbf-pum-direct from="" to="" direction="{string}" constraint="{string}" polynomial="separate" vertices-per-cluster="50" relative-overlap="0.15" project-to-input="true">
  <executor:cpu/>
  <basis-function:compact-polynomial-c0 support-radius="{float}"/>
</mapping:rbf-pum-direct>
AttributeTypeDescriptionDefaultOptions
fromstringThe mesh to map the data from. The default name is an empty mesh name, which is only valid for a just-in-time mapping (using the API functions “writeAndMapData” or “mapAndReadData”).``none
tostringThe mesh to map the data to. The default name is an empty mesh name, which is only valid for a just-in-time mapping (using the API functions “writeAndMapData” or “mapAndReadData”).``none
directionstringWrite mappings map written data prior to communication, thus in the same participant who writes the data. Read mappings map received data after communication, thus in the same participant who reads the data.nonewrite, read
constraintstringUse conservative to conserve the nodal sum of the data over the interface (needed e.g. for force mapping). Use consistent for normalized quantities such as temperature or pressure. Use scaled-consistent-surface or scaled-consistent-volume for normalized quantities where conservation of integral values (surface or volume) is needed (e.g. velocities when the mass flow rate needs to be conserved). Mesh connectivity is required to use scaled-consistent.noneconservative, consistent, scaled-consistent-surface, scaled-consistent-volume
polynomialstringToggles use a local (per cluster) polynomialseparateoff, separate
vertices-per-clusterintegerAverage number of vertices per cluster (partition) applied in the rbf partition of unity method.50none
relative-overlapfloatValue between 0 and 1 indicating the relative overlap between clusters. A value of 0.15 is usually a good trade-off between accuracy and efficiency.0.15none
project-to-inputbooleanIf enabled, places the cluster centers at the closest vertex of the input mesh. Should be enabled in case of non-uniform point distributions such as for shell structures.truenone

Valid Subtags:

executor:cpu

The default executor using a CPU and a distributed memory parallelism via MPI.

Example:

<executor:cpu/>

executor:cuda

Cuda (Nvidia) executor, which uses Kokkos-kernels, fully parallel

Example:

<executor:cuda gpu-device-id="0" execution-mode="minimal-memory"/>
AttributeTypeDescriptionDefaultOptions
gpu-device-idstringSetting of the GPU device: Set “auto” to assign GPUs to each MPI rank in a round robin fashion or specify a number between 0 and the number of available GPUs-1 to assign all MPI ranks to one GPU device with the given ID.0none
execution-modestringToggle to switch between a minimal-memory vs a minimal-compute algorithm. For option “minimal-memory”, the RBF evaluation is recomputed for each data mapping on-the-fly, which saves approximately half the memory consumption (if meshes have a similar resolution), but may (!) be slower (depends heavily on the hardware). For the option “minimal-compute”, the RBF evaluation is precomputed, which may be faster, but consumes more memory.minimal-memoryminimal-memory, minimal-compute

executor:hip

Hip (AMD/Nvidia) executor, which uses Kokkos-kernels, fully parallel.

Example:

<executor:hip gpu-device-id="0" execution-mode="minimal-memory"/>
AttributeTypeDescriptionDefaultOptions
gpu-device-idstringSetting of the GPU device: Set “auto” to assign GPUs to each MPI rank in a round robin fashion or specify a number between 0 and the number of available GPUs-1 to assign all MPI ranks to one GPU device with the given ID.0none
execution-modestringToggle to switch between a minimal-memory vs a minimal-compute algorithm. For option “minimal-memory”, the RBF evaluation is recomputed for each data mapping on-the-fly, which saves approximately half the memory consumption (if meshes have a similar resolution), but may (!) be slower (depends heavily on the hardware). For the option “minimal-compute”, the RBF evaluation is precomputed, which may be faster, but consumes more memory.minimal-memoryminimal-memory, minimal-compute

executor:sycl

SYCL (e.g. Intel) executor, which uses Kokkos-kernels, fully parallel.

Example:

<executor:sycl gpu-device-id="0" execution-mode="minimal-memory"/>
AttributeTypeDescriptionDefaultOptions
gpu-device-idstringSetting of the GPU device: Set “auto” to assign GPUs to each MPI rank in a round robin fashion or specify a number between 0 and the number of available GPUs-1 to assign all MPI ranks to one GPU device with the given ID.0none
execution-modestringToggle to switch between a minimal-memory vs a minimal-compute algorithm. For option “minimal-memory”, the RBF evaluation is recomputed for each data mapping on-the-fly, which saves approximately half the memory consumption (if meshes have a similar resolution), but may (!) be slower (depends heavily on the hardware). For the option “minimal-compute”, the RBF evaluation is precomputed, which may be faster, but consumes more memory.minimal-memoryminimal-memory, minimal-compute

executor:openmp

OpenMP executor, which uses Kokkos-kernel, fully parallel.

Example:

<executor:openmp n-threads="0" execution-mode="minimal-memory"/>
AttributeTypeDescriptionDefaultOptions
n-threadsintegerSpecifies the number of threads for the OpenMP executor that should be used for the Ginkgo OpenMP backend. If a value of “0” is set, preCICE doesn’t set the number of threads and the default behavior of OpenMP applies.0none
execution-modestringToggle to switch between a minimal-memory vs a minimal-compute algorithm. For option “minimal-memory”, the RBF evaluation is recomputed for each data mapping on-the-fly, which saves approximately half the memory consumption (if meshes have a similar resolution), but may (!) be slower (depends heavily on the hardware). For the option “minimal-compute”, the RBF evaluation is precomputed, which may be faster, but consumes more memory.minimal-memoryminimal-memory, minimal-compute

basis-function:compact-polynomial-c0

Wendland C0 function

Example:

<basis-function:compact-polynomial-c0 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:compact-polynomial-c2

Wendland C2 function

Example:

<basis-function:compact-polynomial-c2 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:compact-polynomial-c4

Wendland C4 function

Example:

<basis-function:compact-polynomial-c4 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:compact-polynomial-c6

Wendland C6 function

Example:

<basis-function:compact-polynomial-c6 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:compact-polynomial-c8

Wendland C8 function

Example:

<basis-function:compact-polynomial-c8 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:compact-tps-c2

Compact thin-plate-spline C2

Example:

<basis-function:compact-tps-c2 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:multiquadrics

Multiquadrics

Example:

<basis-function:multiquadrics shape-parameter="{float}"/>
AttributeTypeDescriptionDefaultOptions
shape-parameterfloatSpecific shape parameter for RBF basis function.nonenone

basis-function:inverse-multiquadrics

Inverse multiquadrics

Example:

<basis-function:inverse-multiquadrics shape-parameter="{float}"/>
AttributeTypeDescriptionDefaultOptions
shape-parameterfloatSpecific shape parameter for RBF basis function.nonenone

basis-function:gaussian

Gaussian basis function accepting a support radius or a shape parameter.

Example:

<basis-function:gaussian shape-parameter="nan" support-radius="nan"/>
AttributeTypeDescriptionDefaultOptions
shape-parameterfloatSpecific shape parameter for RBF basis function.nannone
support-radiusfloatSupport radius of each RBF basis function (global choice).nannone

basis-function:thin-plate-splines

Thin-plate-splines

Example:

<basis-function:thin-plate-splines/>

basis-function:volume-splines

Volume splines

Example:

<basis-function:volume-splines/>

mapping:rbf

Alias tag, which auto-selects a radial-basis-function mapping depending on the simulation parameter,

Example:

<mapping:rbf from="" to="" direction="{string}" constraint="{string}" x-dead="false" y-dead="false" z-dead="false">
  <basis-function:compact-polynomial-c0 support-radius="{float}"/>
</mapping:rbf>
AttributeTypeDescriptionDefaultOptions
fromstringThe mesh to map the data from. The default name is an empty mesh name, which is only valid for a just-in-time mapping (using the API functions “writeAndMapData” or “mapAndReadData”).``none
tostringThe mesh to map the data to. The default name is an empty mesh name, which is only valid for a just-in-time mapping (using the API functions “writeAndMapData” or “mapAndReadData”).``none
directionstringWrite mappings map written data prior to communication, thus in the same participant who writes the data. Read mappings map received data after communication, thus in the same participant who reads the data.nonewrite, read
constraintstringUse conservative to conserve the nodal sum of the data over the interface (needed e.g. for force mapping). Use consistent for normalized quantities such as temperature or pressure. Use scaled-consistent-surface or scaled-consistent-volume for normalized quantities where conservation of integral values (surface or volume) is needed (e.g. velocities when the mass flow rate needs to be conserved). Mesh connectivity is required to use scaled-consistent.noneconservative, consistent, scaled-consistent-surface, scaled-consistent-volume
x-deadbooleanIf set to true, the x axis will be ignored for the mappingfalsenone
y-deadbooleanIf set to true, the y axis will be ignored for the mappingfalsenone
z-deadbooleanIf set to true, the z axis will be ignored for the mappingfalsenone

Valid Subtags:

basis-function:compact-polynomial-c0

Wendland C0 function

Example:

<basis-function:compact-polynomial-c0 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:compact-polynomial-c2

Wendland C2 function

Example:

<basis-function:compact-polynomial-c2 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:compact-polynomial-c4

Wendland C4 function

Example:

<basis-function:compact-polynomial-c4 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:compact-polynomial-c6

Wendland C6 function

Example:

<basis-function:compact-polynomial-c6 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:compact-polynomial-c8

Wendland C8 function

Example:

<basis-function:compact-polynomial-c8 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:compact-tps-c2

Compact thin-plate-spline C2

Example:

<basis-function:compact-tps-c2 support-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
support-radiusfloatSupport radius of each RBF basis function (global choice).nonenone

basis-function:multiquadrics

Multiquadrics

Example:

<basis-function:multiquadrics shape-parameter="{float}"/>
AttributeTypeDescriptionDefaultOptions
shape-parameterfloatSpecific shape parameter for RBF basis function.nonenone

basis-function:inverse-multiquadrics

Inverse multiquadrics

Example:

<basis-function:inverse-multiquadrics shape-parameter="{float}"/>
AttributeTypeDescriptionDefaultOptions
shape-parameterfloatSpecific shape parameter for RBF basis function.nonenone

basis-function:gaussian

Gaussian basis function accepting a support radius or a shape parameter.

Example:

<basis-function:gaussian shape-parameter="nan" support-radius="nan"/>
AttributeTypeDescriptionDefaultOptions
shape-parameterfloatSpecific shape parameter for RBF basis function.nannone
support-radiusfloatSupport radius of each RBF basis function (global choice).nannone

basis-function:thin-plate-splines

Thin-plate-splines

Example:

<basis-function:thin-plate-splines/>

basis-function:volume-splines

Volume splines

Example:

<basis-function:volume-splines/>

mapping:coarse-graining

Coarse graining specifically designed for particle-mesh coupling to write data from the particles to the mesh. The mapping transforms an extensive quantity (e.g., volume, force) into an intensive quantity (e.g., porosity, force-density). Currently implemented as just-in-time mapping. Although the constraint does not really fit here (the input is conservative, the output not), we classify it as “conservative” for the configuration.

Example:

<mapping:coarse-graining from="" to="" direction="{string}" constraint="{string}" radius="0"/>
AttributeTypeDescriptionDefaultOptions
fromstringThe mesh to map the data from. The default name is an empty mesh name, which is only valid for a just-in-time mapping (using the API functions “writeAndMapData” or “mapAndReadData”).``none
tostringThe mesh to map the data to. The default name is an empty mesh name, which is only valid for a just-in-time mapping (using the API functions “writeAndMapData” or “mapAndReadData”).``none
directionstringWrite mappings map written data prior to communication, thus in the same participant who writes the data. Read mappings map received data after communication, thus in the same participant who reads the data.nonewrite, read
constraintstringUse conservative to conserve the nodal sum of the data over the interface (needed e.g. for force mapping). Use consistent for normalized quantities such as temperature or pressure. Use scaled-consistent-surface or scaled-consistent-volume for normalized quantities where conservation of integral values (surface or volume) is needed (e.g. velocities when the mass flow rate needs to be conserved). Mesh connectivity is required to use scaled-consistent.noneconservative, consistent, scaled-consistent-surface, scaled-consistent-volume
radiusfloatRadius or range of the coarsening function (Lucy function).0none

mapping:axial-geometric-multiscale

Axial geometric multiscale mapping between one 1D and multiple 3D vertices.

Example:

<mapping:axial-geometric-multiscale from="" to="" direction="{string}" constraint="{string}" multiscale-dimension="{string}" multiscale-type="{string}" multiscale-axis="{string}" multiscale-radius="{float}" multiscale-cross-section-profile="uniform" multiscale-cross-section="circle"/>
AttributeTypeDescriptionDefaultOptions
fromstringThe mesh to map the data from. The default name is an empty mesh name, which is only valid for a just-in-time mapping (using the API functions “writeAndMapData” or “mapAndReadData”).``none
tostringThe mesh to map the data to. The default name is an empty mesh name, which is only valid for a just-in-time mapping (using the API functions “writeAndMapData” or “mapAndReadData”).``none
directionstringWrite mappings map written data prior to communication, thus in the same participant who writes the data. Read mappings map received data after communication, thus in the same participant who reads the data.nonewrite, read
constraintstringUse conservative to conserve the nodal sum of the data over the interface (needed e.g. for force mapping). Use consistent for normalized quantities such as temperature or pressure. Use scaled-consistent-surface or scaled-consistent-volume for normalized quantities where conservation of integral values (surface or volume) is needed (e.g. velocities when the mass flow rate needs to be conserved). Mesh connectivity is required to use scaled-consistent.noneconservative, consistent, scaled-consistent-surface, scaled-consistent-volume
multiscale-dimensionstringSpecifies the dimensionality pairing used in geometric multiscale mapping. Options: ‘1D-3D’, ‘1D-2D’ or ‘2D-3D’.none1d-3d, 1d-2d, 2d-3d
multiscale-typestringType of geometric multiscale mapping. Either ‘spread’ or ‘collect’.nonespread, collect
multiscale-axisstringPrinciple axis along which geometric multiscale mapping is performed.nonex, y, z
multiscale-radiusfloatRadius of the cross-sectional interface between the participants.nonenone
multiscale-cross-section-profilestringProfile of the mapped variable along the cross-sectional interface: ‘uniform’ or ‘parabolic’uniformuniform, parabolic
multiscale-cross-sectionstringCross section of the interface of the participants: ‘circle’ or ‘square’circlecircle, square

mapping:radial-geometric-multiscale

Radial geometric multiscale mapping between multiple 1D and multiple 3D vertices, distributed along a principle axis.

Example:

<mapping:radial-geometric-multiscale from="" to="" direction="{string}" constraint="{string}" multiscale-type="{string}" multiscale-axis="{string}" multiscale-radius="{float}"/>
AttributeTypeDescriptionDefaultOptions
fromstringThe mesh to map the data from. The default name is an empty mesh name, which is only valid for a just-in-time mapping (using the API functions “writeAndMapData” or “mapAndReadData”).``none
tostringThe mesh to map the data to. The default name is an empty mesh name, which is only valid for a just-in-time mapping (using the API functions “writeAndMapData” or “mapAndReadData”).``none
directionstringWrite mappings map written data prior to communication, thus in the same participant who writes the data. Read mappings map received data after communication, thus in the same participant who reads the data.nonewrite, read
constraintstringUse conservative to conserve the nodal sum of the data over the interface (needed e.g. for force mapping). Use consistent for normalized quantities such as temperature or pressure. Use scaled-consistent-surface or scaled-consistent-volume for normalized quantities where conservation of integral values (surface or volume) is needed (e.g. velocities when the mass flow rate needs to be conserved). Mesh connectivity is required to use scaled-consistent.noneconservative, consistent, scaled-consistent-surface, scaled-consistent-volume
multiscale-typestringType of geometric multiscale mapping. Either ‘spread’ or ‘collect’.nonespread, collect
multiscale-axisstringPrinciple axis along which geometric multiscale mapping is performed.nonex, y, z
multiscale-radiusfloatRadius of the cross-sectional interface between the participants.nonenone

action:multiply-by-area

Multiplies data values with mesh area associated to vertex holding the value.

Example:

<action:multiply-by-area timing="{string}" mesh="{string}">
  <target-data name="{string}"/>
</action:multiply-by-area>
AttributeTypeDescriptionDefaultOptions
timingstringDetermines when (relative to advancing the coupling scheme and the data mappings) the action is executed.nonewrite-mapping-post, read-mapping-post
meshstringDetermines mesh used in action.nonenone

Valid Subtags:

target-data

Data to read from and write to.

Example:

<target-data name="{string}"/>
AttributeTypeDescriptionDefaultOptions
namestringName of the data.nonenone

action:divide-by-area

Divides data values by mesh area associated to vertex holding the value.

Example:

<action:divide-by-area timing="{string}" mesh="{string}">
  <target-data name="{string}"/>
</action:divide-by-area>
AttributeTypeDescriptionDefaultOptions
timingstringDetermines when (relative to advancing the coupling scheme and the data mappings) the action is executed.nonewrite-mapping-post, read-mapping-post
meshstringDetermines mesh used in action.nonenone

Valid Subtags:

target-data

Data to read from and write to.

Example:

<target-data name="{string}"/>
AttributeTypeDescriptionDefaultOptions
namestringName of the data.nonenone

action:summation

Sums up multiple source data values and writes the result into target data.

Example:

<action:summation timing="{string}" mesh="{string}">
  <source-data name="{string}"/>
  <target-data name="{string}"/>
</action:summation>
AttributeTypeDescriptionDefaultOptions
timingstringDetermines when (relative to advancing the coupling scheme and the data mappings) the action is executed.nonewrite-mapping-post, read-mapping-post
meshstringDetermines mesh used in action.nonenone

Valid Subtags:

source-data

Multiple data to read from.

Example:

<source-data name="{string}"/>
AttributeTypeDescriptionDefaultOptions
namestringName of the data.nonenone

target-data

Data to read from and write to.

Example:

<target-data name="{string}"/>
AttributeTypeDescriptionDefaultOptions
namestringName of the data.nonenone

action:recorder

Records action invocations for testing purposes.

Example:

<action:recorder timing="{string}" mesh="{string}"/>
AttributeTypeDescriptionDefaultOptions
timingstringDetermines when (relative to advancing the coupling scheme and the data mappings) the action is executed.nonewrite-mapping-post, read-mapping-post
meshstringDetermines mesh used in action.nonenone

action:python

Calls Python script to execute action. See preCICE file “src/action/PythonAction.py” for an example.

Example:

<action:python timing="{string}" mesh="{string}">
  <path name=""/>
  <module name="{string}"/>
  <source-data name="{string}"/>
  <target-data name="{string}"/>
</action:python>
AttributeTypeDescriptionDefaultOptions
timingstringDetermines when (relative to advancing the coupling scheme and the data mappings) the action is executed.nonewrite-mapping-post, read-mapping-post
meshstringDetermines mesh used in action.nonenone

Valid Subtags:

path

Directory path to Python module, i.e. script file. If it doesn’t occur, the current path is used

Example:

<path name=""/>
AttributeTypeDescriptionDefaultOptions
namestringThe path to the directory of the module.``none

module

Name of Python module, i.e. Python script file without file ending. The module name has to differ from existing (library) modules, otherwise, the existing module will be loaded instead of the user script.

Example:

<module name="{string}"/>
AttributeTypeDescriptionDefaultOptions
namestringName of the data.nonenone

source-data

Source data to be read is handed to the Python module. Can be omitted, if only a target data is needed.

Example:

<source-data name="{string}"/>
AttributeTypeDescriptionDefaultOptions
namestringName of the data.nonenone

target-data

Target data to be read and written to is handed to the Python module. Can be omitted, if only source data is needed.

Example:

<target-data name="{string}"/>
AttributeTypeDescriptionDefaultOptions
namestringName of the data.nonenone

export:vtk

Exports meshes to VTK legacy format files. Parallel participants will use the VTU exporter instead.

Example:

<export:vtk directory="." every-n-time-windows="1" every-iteration="false" update-series="false"/>
AttributeTypeDescriptionDefaultOptions
directorystringDirectory to export the files to..none
every-n-time-windowsintegerpreCICE does an export every X time windows. Choose -1 for no exports.1none
every-iterationbooleanExports in every coupling (sub)iteration. For debug purposes.falsenone
update-seriesbooleanUpdate the series file after every export instead of at the end of the simulation.falsenone

export:vtu

Exports meshes to VTU files in serial or PVTU files with VTU piece files in parallel.

Example:

<export:vtu directory="." every-n-time-windows="1" every-iteration="false" update-series="false"/>
AttributeTypeDescriptionDefaultOptions
directorystringDirectory to export the files to..none
every-n-time-windowsintegerpreCICE does an export every X time windows. Choose -1 for no exports.1none
every-iterationbooleanExports in every coupling (sub)iteration. For debug purposes.falsenone
update-seriesbooleanUpdate the series file after every export instead of at the end of the simulation.falsenone

export:vtp

Exports meshes to VTP files in serial or PVTP files with VTP piece files in parallel.

Example:

<export:vtp directory="." every-n-time-windows="1" every-iteration="false" update-series="false"/>
AttributeTypeDescriptionDefaultOptions
directorystringDirectory to export the files to..none
every-n-time-windowsintegerpreCICE does an export every X time windows. Choose -1 for no exports.1none
every-iterationbooleanExports in every coupling (sub)iteration. For debug purposes.falsenone
update-seriesbooleanUpdate the series file after every export instead of at the end of the simulation.falsenone

export:csv

Exports vertex coordinates and data to CSV files.

Example:

<export:csv directory="." every-n-time-windows="1" every-iteration="false" update-series="false"/>
AttributeTypeDescriptionDefaultOptions
directorystringDirectory to export the files to..none
every-n-time-windowsintegerpreCICE does an export every X time windows. Choose -1 for no exports.1none
every-iterationbooleanExports in every coupling (sub)iteration. For debug purposes.falsenone
update-seriesbooleanUpdate the series file after every export instead of at the end of the simulation.falsenone

watch-point

A watch point can be used to follow the transient changes of data and mesh vertex coordinates at a given point

Example:

<watch-point name="{string}" mesh="{string}" coordinate="{vector}"/>
AttributeTypeDescriptionDefaultOptions
namestringName of the watch point. Is taken in combination with the participant name to construct the filename the watch point data is written to.nonenone
meshstringMesh to be watched.nonenone
coordinatevectorThe coordinates of the watch point. If the watch point is not put exactly on the mesh to observe, the closest projection of the point onto the mesh is considered instead, and values/coordinates are interpolated linearly to that point.nonenone

watch-integral

A watch integral can be used to follow the transient change of integral data and surface area for a given coupling mesh.

Example:

<watch-integral name="{string}" mesh="{string}" scale-with-connectivity="{boolean}"/>
AttributeTypeDescriptionDefaultOptions
namestringName of the watch integral. Is taken in combination with the participant name to construct the filename the watch integral data is written to.nonenone
meshstringMesh to be watched.nonenone
scale-with-connectivitybooleanWhether the vertex data is scaled with the element area before summing up or not. In 2D, vertex data is scaled with the average length of neighboring edges. In 3D, vertex data is scaled with the average surface of neighboring triangles. If false, vertex data is directly summed up.nonenone

provide-mesh

Provide a mesh (see tag <mesh>) to other participants.

Example:

<provide-mesh name="{string}"/>
AttributeTypeDescriptionDefaultOptions
namestringName of the mesh to provide.nonenone

receive-mesh

Makes a remote mesh (see tag <mesh>) available to this participant.

Example:

<receive-mesh name="{string}" api-access="false" direct-access="false" geometric-filter="on-secondary-ranks" from="{string}" safety-factor="0.5"/>
AttributeTypeDescriptionDefaultOptions
namestringName of the mesh to receive.nonenone
api-accessbooleanEnables access to the data on this received mesh via the preCICE API functions without having to map it to a provided mesh. This is required for direct access or just-in-time mappings. A received mesh needs to be decomposed in preCICE using a region of interest, which cannot be inferred, if there are no mappings to or from a provided mesh. In such cases the API function setMeshAccessRegion() must be used to define the region of interest. See the user documentation for more information.falsenone
direct-accessbooleanDeprecated: use “api-access” instead.falsenone
geometric-filterstringFor parallel execution, a received mesh needs to be decomposed. A geometric filter based on bounding-boxes around the local mesh can speed up this process. This setting controls if and where this filter is applied. on-primary-rank is beneficial for a huge mesh and a low number of processors, but is incompatible with two-level initialization. on-secondary-ranks performs better for a very high number of processors. Both result in the same distribution if the safety-factor is sufficiently large. no-filter may be useful for very asymmetric cases and for debugging. If a mapping based on RBFs (rbf-pum,global-rbf) is used, the filter has no influence and is always no-filter.on-secondary-ranksno-filter, on-primary-rank, on-secondary-ranks
fromstringThe name of the participant to receive the mesh from. This participant needs to provide the mesh using <provide-mesh />.nonenone
safety-factorfloatThe safety factor of the geometric filter uniformly scales the rank-local bounding box by the given factor. A safety-factor of 0.5 means that the bounding box is 150% of its original size.0.5none

intra-comm:sockets

A solver in parallel needs a communication between its ranks. By default, the participant’s MPI_COM_WORLD is reused.Use this tag to use TCP/IP sockets instead.

Example:

<intra-comm:sockets port="0" network="lo" exchange-directory="."/>
AttributeTypeDescriptionDefaultOptions
portintegerPort number (16-bit unsigned integer) to be used for socket communication. The default is “0”, what means that OS will dynamically search for a free port (if at least one exists) and bind it automatically.0none
networkstringInterface name to be used for socket communication. Default is the canonical name of the loopback interface of your platform. Might be different on supercomputing systems, e.g. “ib0” for the InfiniBand on SuperMUC.lonone
exchange-directorystringDirectory where connection information is exchanged. By default, the directory of startup is chosen..none

intra-comm:mpi

A solver in parallel needs a communication between its ranks. By default, the participant’s MPI_COM_WORLD is reused.Use this tag to use MPI with separated communication spaces instead instead.

Example:

<intra-comm:mpi exchange-directory="."/>
AttributeTypeDescriptionDefaultOptions
exchange-directorystringDirectory where connection information is exchanged. By default, the directory of startup is chosen..none

coupling-scheme:serial-explicit

Explicit coupling scheme according to conventional serial staggered procedure (CSS).

Example:

<coupling-scheme:serial-explicit>
  <max-time value="{float}"/>
  <max-time-windows value="{integer}"/>
  <time-window-size value="-1" method="fixed"/>
  <participants first="{string}" second="{string}"/>
  <exchange data="{string}" mesh="{string}" from="{string}" to="{string}" initialize="false" substeps="false"/>
</coupling-scheme:serial-explicit>

Valid Subtags:

max-time

Defined the end of the simulation as total time.

Example:

<max-time value="{float}"/>
AttributeTypeDescriptionDefaultOptions
valuefloatThe value of the maximum simulation time.nonenone

max-time-windows

Defined the end of the simulation as a total count of time windows.

Example:

<max-time-windows value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe maximum count of time windows.nonenone

time-window-size

Defines the size of the time window.

Example:

<time-window-size value="-1" method="fixed"/>
AttributeTypeDescriptionDefaultOptions
valuefloatThe maximum time window size.-1none
methodstringThe method used to determine the time window size. Use fixed to fix the time window size for the participants.fixedfixed, first-participant

participants

Defines the participants of the coupling scheme.

Example:

<participants first="{string}" second="{string}"/>
AttributeTypeDescriptionDefaultOptions
firststringFirst participant to run the solver.nonenone
secondstringSecond participant to run the solver.nonenone

exchange

Defines the flow of data between meshes of participants.

Example:

<exchange data="{string}" mesh="{string}" from="{string}" to="{string}" initialize="false" substeps="false"/>
AttributeTypeDescriptionDefaultOptions
datastringThe data to exchange.nonenone
meshstringThe mesh which uses the data.nonenone
fromstringThe participant sending the data.nonenone
tostringThe participant receiving the data.nonenone
initializebooleanShould this data be initialized during initialize?falsenone
substepsbooleanShould this data exchange substeps?falsenone

coupling-scheme:parallel-explicit

Explicit coupling scheme according to conventional parallel staggered procedure (CPS).

Example:

<coupling-scheme:parallel-explicit>
  <max-time value="{float}"/>
  <max-time-windows value="{integer}"/>
  <time-window-size value="-1"/>
  <participants first="{string}" second="{string}"/>
  <exchange data="{string}" mesh="{string}" from="{string}" to="{string}" initialize="false" substeps="false"/>
</coupling-scheme:parallel-explicit>

Valid Subtags:

max-time

Defined the end of the simulation as total time.

Example:

<max-time value="{float}"/>
AttributeTypeDescriptionDefaultOptions
valuefloatThe value of the maximum simulation time.nonenone

max-time-windows

Defined the end of the simulation as a total count of time windows.

Example:

<max-time-windows value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe maximum count of time windows.nonenone

time-window-size

Defines the size of the time window.

Example:

<time-window-size value="-1"/>
AttributeTypeDescriptionDefaultOptions
valuefloatThe maximum time window size.-1none

participants

Defines the participants of the coupling scheme.

Example:

<participants first="{string}" second="{string}"/>
AttributeTypeDescriptionDefaultOptions
firststringFirst participant to run the solver.nonenone
secondstringSecond participant to run the solver.nonenone

exchange

Defines the flow of data between meshes of participants.

Example:

<exchange data="{string}" mesh="{string}" from="{string}" to="{string}" initialize="false" substeps="false"/>
AttributeTypeDescriptionDefaultOptions
datastringThe data to exchange.nonenone
meshstringThe mesh which uses the data.nonenone
fromstringThe participant sending the data.nonenone
tostringThe participant receiving the data.nonenone
initializebooleanShould this data be initialized during initialize?falsenone
substepsbooleanShould this data exchange substeps?falsenone

coupling-scheme:serial-implicit

Implicit coupling scheme according to block Gauss-Seidel iterations (S-System). Improved implicit iterations are achieved by using a acceleration (recommended!).

Example:

<coupling-scheme:serial-implicit>
  <max-time value="{float}"/>
  <max-time-windows value="{integer}"/>
  <time-window-size value="-1" method="fixed"/>
  <participants first="{string}" second="{string}"/>
  <exchange data="{string}" mesh="{string}" from="{string}" to="{string}" initialize="false" substeps="true"/>
  <acceleration:constant>
    ...
  </acceleration:constant>
  <absolute-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" limit="{float}"/>
  <absolute-or-relative-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" abs-limit="{float}" rel-limit="{float}"/>
  <relative-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" limit="{float}"/>
  <residual-relative-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" limit="{float}"/>
  <min-iterations value="{integer}"/>
  <max-iterations value="{integer}"/>
</coupling-scheme:serial-implicit>

Valid Subtags:

max-time

Defined the end of the simulation as total time.

Example:

<max-time value="{float}"/>
AttributeTypeDescriptionDefaultOptions
valuefloatThe value of the maximum simulation time.nonenone

max-time-windows

Defined the end of the simulation as a total count of time windows.

Example:

<max-time-windows value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe maximum count of time windows.nonenone

time-window-size

Defines the size of the time window.

Example:

<time-window-size value="-1" method="fixed"/>
AttributeTypeDescriptionDefaultOptions
valuefloatThe maximum time window size.-1none
methodstringThe method used to determine the time window size. Use fixed to fix the time window size for the participants.fixedfixed, first-participant

participants

Defines the participants of the coupling scheme.

Example:

<participants first="{string}" second="{string}"/>
AttributeTypeDescriptionDefaultOptions
firststringFirst participant to run the solver.nonenone
secondstringSecond participant to run the solver.nonenone

exchange

Defines the flow of data between meshes of participants.

Example:

<exchange data="{string}" mesh="{string}" from="{string}" to="{string}" initialize="false" substeps="true"/>
AttributeTypeDescriptionDefaultOptions
datastringThe data to exchange.nonenone
meshstringThe mesh which uses the data.nonenone
fromstringThe participant sending the data.nonenone
tostringThe participant receiving the data.nonenone
initializebooleanShould this data be initialized during initialize?falsenone
substepsbooleanShould this data exchange substeps?truenone

acceleration:constant

Accelerates coupling data with constant underrelaxation.

Example:

<acceleration:constant>
  <relaxation value="{float}"/>
</acceleration:constant>

Valid Subtags:

relaxation

Example:

<relaxation value="{float}"/>
AttributeTypeDescriptionDefaultOptions
valuefloatConstant relaxation factor.nonenone

acceleration:aitken

Accelerates coupling data with dynamic Aitken under-relaxation.

Example:

<acceleration:aitken>
  <initial-relaxation value="{float}"/>
  <data scaling="1" name="{string}" mesh="{string}"/>
  <preconditioner type="{string}" freeze-after="-1"/>
</acceleration:aitken>

Valid Subtags:

initial-relaxation

Initial relaxation factor. If this tag is not provided, an initial relaxation of 0.5 is used.

Example:

<initial-relaxation value="{float}"/>
AttributeTypeDescriptionDefaultOptions
valuefloatInitial relaxation factor.nonenone

data

The data used to compute the acceleration.

Example:

<data scaling="1" name="{string}" mesh="{string}"/>
AttributeTypeDescriptionDefaultOptions
scalingfloatTo improve the performance of a parallel or a multi coupling schemes, each data set can be manually scaled using this scaling factor with preconditioner type = “constant”. For all other preconditioner types, the factor is ignored. We recommend, however, to use an automatic scaling via a preconditioner.1none
namestringThe name of the data.nonenone
meshstringThe name of the mesh which holds the data.nonenone

preconditioner

To improve the numerical stability of multiple data vectors a preconditioner can be applied. A constant preconditioner scales every acceleration data by a constant value, which you can define as an attribute of data. A value preconditioner scales every acceleration data by the norm of the data in the previous time window. A residual preconditioner scales every acceleration data by the current residual. A residual-sum preconditioner scales every acceleration data by the sum of the residuals from the current time window.

Example:

<preconditioner type="{string}" freeze-after="-1"/>
AttributeTypeDescriptionDefaultOptions
typestringThe type of the preconditioner.noneconstant, value, residual, residual-sum
freeze-afterintegerAfter the given number of time windows, the preconditioner weights are frozen and the preconditioner acts like a constant preconditioner.-1none

acceleration:IQN-ILS

Accelerates coupling data with the interface quasi-Newton inverse least-squares method.

Example:

<acceleration:IQN-ILS reduced-time-grid="true" on-bound-violation="ignore">
  <initial-relaxation value="{float}" enforce="false"/>
  <max-used-iterations value="{integer}"/>
  <time-windows-reused value="{integer}"/>
  <data name="{string}" mesh="{string}" scaling="1"/>
  <filter limit="1e-16" type="QR3"/>
  <preconditioner type="{string}" update-on-threshold="true" freeze-after="-1"/>
</acceleration:IQN-ILS>
AttributeTypeDescriptionDefaultOptions
reduced-time-gridbooleanWhether only the last time step of each time window is used to construct the Jacobian.truenone
on-bound-violationstringDefines the strategy to handle updates that violate variable bounds. Use ignore when no special handling is desired. Use clamp to limit the violating components to their bounds. Use discard to skip the QN update when a bound violation occurs. Use scale to scale the QN step with a constant to fit all violating components into the bounds.ignoreignore, clamp, discard, scale

Valid Subtags:

initial-relaxation

Initial relaxation factor. If this tag is not provided, an initial relaxation of 0.1 is used.

Example:

<initial-relaxation value="{float}" enforce="false"/>
AttributeTypeDescriptionDefaultOptions
valuefloatInitial relaxation factor.nonenone
enforcebooleanEnforce initial relaxation in every time window.falsenone

max-used-iterations

Maximum number of columns used in low-rank approximation of Jacobian. If this tag is not provided, the attribute value of 100 is used.

Example:

<max-used-iterations value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe number of columns.nonenone

time-windows-reused

Number of past time windows from which columns are used to approximate Jacobian. If this tag is not provided, the default attribute value of 10 is used.

Example:

<time-windows-reused value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe number of time windows.nonenone

data

The data used to compute the acceleration.

Example:

<data name="{string}" mesh="{string}" scaling="1"/>
AttributeTypeDescriptionDefaultOptions
namestringThe name of the data.nonenone
meshstringThe name of the mesh which holds the data.nonenone
scalingfloatTo improve the performance of a parallel or a multi coupling schemes, each data set can be manually scaled using this scaling factor with preconditioner type = “constant”. For all other preconditioner types, the factor is ignored. We recommend, however, to use an automatic scaling via a preconditioner.1none

filter

Type of filtering technique that is used to maintain good conditioning in the least-squares system. Possible filters:

  • QR1: update QR-dec with (relative) test \(R(i,i) < \epsilon *\lVert R\rVert_F\)

  • QR1-absolute: update QR-dec with (absolute) test \(R(i, i) < \epsilon\)

  • QR2: en-block QR-dec with test \(\lVert v_\text{orth} \rVert_2 < \epsilon * \lVert v \rVert_2\)

  • QR3: update QR-dec only when the pre-scaling weights have changed or there is one or more columns are to be removed with test \(\lVert v_\text{orth} \rVert_2 < \epsilon * \lVert v \rVert_2\)

Please note that a QR1 is based on Given’s rotations whereas QR2 uses modified Gram-Schmidt. This can give different results even when no columns are filtered out.

Example:

<filter limit="1e-16" type="QR3"/>
AttributeTypeDescriptionDefaultOptions
limitfloatLimit eps of the filter.1e-16none
typestringType of the filter.QR3QR1, QR1-absolute, QR2, QR3

preconditioner

To improve the performance of a parallel or a multi coupling schemes a preconditioner can be applied.

  • A constant preconditioner scales every acceleration data by a constant value, which you can define as an attribute of data.
  • A value preconditioner scales every acceleration data by the norm of the data in the previous time window.
  • A residual preconditioner scales every acceleration data by the current residual.
  • A residual-sum preconditioner scales every acceleration data by the sum of the residuals from the current time window.

If this tag is not provided, the residual-sum preconditioner is employed.

Example:

<preconditioner type="{string}" update-on-threshold="true" freeze-after="-1"/>
AttributeTypeDescriptionDefaultOptions
typestringThe type of the preconditioner.noneconstant, value, residual, residual-sum
update-on-thresholdbooleanTo update the preconditioner weights after the first time window: true: The preconditioner weights are only updated if the weights will change by more than one order of magnitude. false: The preconditioner weights are updated after every iteration.truenone
freeze-afterintegerAfter the given number of time windows, the preconditioner weights are frozen and the preconditioner acts like a constant preconditioner.-1none

acceleration:IQN-IMVJ

Accelerates coupling data with the interface quasi-Newton inverse multi-vector Jacobian method.

Example:

<acceleration:IQN-IMVJ always-build-jacobian="false" reduced-time-grid="true" on-bound-violation="ignore">
  <initial-relaxation value="{float}" enforce="false"/>
  <imvj-restart-mode type="RS-SVD" chunk-size="8" reused-time-windows-at-restart="8" truncation-threshold="0.0001"/>
  <max-used-iterations value="{integer}"/>
  <time-windows-reused value="{integer}"/>
  <data name="{string}" mesh="{string}" scaling="1"/>
  <filter limit="1e-16" type="QR3"/>
  <preconditioner type="{string}" update-on-threshold="true" freeze-after="-1"/>
</acceleration:IQN-IMVJ>
AttributeTypeDescriptionDefaultOptions
always-build-jacobianbooleanIf set to true, the IMVJ will set up the Jacobian matrix in each coupling iteration, which is inefficient. If set to false (or not set) the Jacobian is only build in the last iteration and the updates are computed using (relatively) cheap MATVEC products.falsenone
reduced-time-gridbooleanWhether only the last time step of each time window is used to construct the Jacobian.truenone
on-bound-violationstringDefines the strategy to handle updates that violate variable bounds. Use ignore when no special handling is desired. Use clamp to limit the violating components to their bounds. Use discard to skip the QN update when a bound violation occurs. Use scale to scale the QN step with a constant to fit all violating components into the bounds.ignoreignore, clamp, discard, scale

Valid Subtags:

initial-relaxation

Initial relaxation factor. If this tag is not provided, an initial relaxation of 0.1 is used.

Example:

<initial-relaxation value="{float}" enforce="false"/>
AttributeTypeDescriptionDefaultOptions
valuefloatInitial relaxation factor.nonenone
enforcebooleanEnforce initial relaxation in every time window.falsenone

imvj-restart-mode

Enable IMVJ Type of IMVJ restart mode that is used: no-restart: IMVJ runs in normal mode with explicit representation of Jacobian. RS-0: IMVJ runs in restart mode. After M time windows all Jacobain information is dropped, restart with no information. RS-LS: IMVJ runs in restart mode. After M time windows a IQN-LS like approximation for the initial guess of the Jacobian is computed. RS-SVD: IMVJ runs in restart mode. After M time windows a truncated SVD of the Jacobian is updated. RS-SLIDE: IMVJ runs in sliding window restart mode. If this tag is not provided, IMVJ runs in restart mode with SVD-method.

Example:

<imvj-restart-mode type="RS-SVD" chunk-size="8" reused-time-windows-at-restart="8" truncation-threshold="0.0001"/>
AttributeTypeDescriptionDefaultOptions
typestringType of the restart mode.RS-SVDno-restart, RS-0, RS-LS, RS-SVD, RS-SLIDE
chunk-sizeintegerSpecifies the number of time windows M after which the IMVJ restarts, if run in restart-mode. Default value is M=8.8none
reused-time-windows-at-restartintegerIf IMVJ restart-mode=RS-LS, the number of reused time windows at restart can be specified.8none
truncation-thresholdfloatIf IMVJ restart-mode=RS-SVD, the truncation threshold for the updated SVD can be set.0.0001none

max-used-iterations

Maximum number of columns used in low-rank approximation of Jacobian. If this tag is not provided, the default attribute value of 20 is used.

Example:

<max-used-iterations value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe number of columns.nonenone

time-windows-reused

Number of past time windows from which columns are used to approximate Jacobian. If this tag is not provided, the attribute value of 0 is used.

Example:

<time-windows-reused value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe number of columns.nonenone

data

The data used to compute the acceleration.

Example:

<data name="{string}" mesh="{string}" scaling="1"/>
AttributeTypeDescriptionDefaultOptions
namestringThe name of the data.nonenone
meshstringThe name of the mesh which holds the data.nonenone
scalingfloatTo improve the performance of a parallel or a multi coupling schemes, each data set can be manually scaled using this scaling factor with preconditioner type = “constant”. For all other preconditioner types, the factor is ignored. We recommend, however, to use an automatic scaling via a preconditioner.1none

filter

Type of filtering technique that is used to maintain good conditioning in the least-squares system. Possible filters:

  • QR1: update QR-dec with (relative) test \(R(i,i) < \epsilon *\lVert R\rVert_F\)

  • QR1-absolute: update QR-dec with (absolute) test \(R(i, i) < \epsilon\)

  • QR2: en-block QR-dec with test \(\lVert v_\text{orth} \rVert_2 < \epsilon * \lVert v \rVert_2\)

  • QR3: update QR-dec only when the pre-scaling weights have changed or there is one or more columns are to be removed with test \(\lVert v_\text{orth} \rVert_2 < \epsilon * \lVert v \rVert_2\)

Please note that a QR1 is based on Given’s rotations whereas QR2 uses modified Gram-Schmidt. This can give different results even when no columns are filtered out.

Example:

<filter limit="1e-16" type="QR3"/>
AttributeTypeDescriptionDefaultOptions
limitfloatLimit eps of the filter.1e-16none
typestringType of the filter.QR3QR1, QR1-absolute, QR2, QR3

preconditioner

To improve the performance of a parallel or a multi coupling schemes a preconditioner can be applied.

  • A constant preconditioner scales every acceleration data by a constant value, which you can define as an attribute of data.
  • A value preconditioner scales every acceleration data by the norm of the data in the previous time window.
  • A residual preconditioner scales every acceleration data by the current residual.
  • A residual-sum preconditioner scales every acceleration data by the sum of the residuals from the current time window.

If this tag is not provided, the residual-sum preconditioner is employed.

Example:

<preconditioner type="{string}" update-on-threshold="true" freeze-after="-1"/>
AttributeTypeDescriptionDefaultOptions
typestringType of the preconditioner.noneconstant, value, residual, residual-sum
update-on-thresholdbooleanTo update the preconditioner weights after the first time window: true: The preconditioner weights are only updated if the weights will change by more than one order of magnitude. false: The preconditioner weights are updated after every iteration.truenone
freeze-afterintegerAfter the given number of time windows, the preconditioner weights are frozen and the preconditioner acts like a constant preconditioner.-1none

absolute-convergence-measure

Absolute convergence criterion based on the two-norm difference of data values between iterations. $$\left\lVert H(x^k) - x^k \right\rVert_2 < \text{limit}$$

Example:

<absolute-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" limit="{float}"/>
AttributeTypeDescriptionDefaultOptions
datastringData to be measured.nonenone
meshstringMesh holding the data.nonenone
sufficesbooleanIf true, convergence of this measure is sufficient for overall convergence.falsenone
strictbooleanIf true, non-convergence of this measure ends the simulation. “strict” overrules “suffices”.falsenone
limitfloatLimit under which the measure is considered to have converged. Must be in ((0, 1]).nonenone

absolute-or-relative-convergence-measure

Absolute or relative convergence, which is the disjunction of an absolute criterion based on the two-norm difference of data values between iterations and a relative criterion based on the relative two-norm difference of data values between iterations,i.e. convergence is reached as soon as one of the both criteria is fulfilled. $$\left\lVert H(x^k) - x^k \right\rVert_2 < \text{abs-limit}\quad\text{or}\quad\frac{\left\lVert H(x^k) - x^k \right\rVert_2}{\left\lVert H(x^k) \right\rVert_2} < \text{rel-limit} $$

Example:

<absolute-or-relative-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" abs-limit="{float}" rel-limit="{float}"/>
AttributeTypeDescriptionDefaultOptions
datastringData to be measured.nonenone
meshstringMesh holding the data.nonenone
sufficesbooleanIf true, convergence of this measure is sufficient for overall convergence.falsenone
strictbooleanIf true, non-convergence of this measure ends the simulation. “strict” overrules “suffices”.falsenone
abs-limitfloatAbsolute limit under which the measure is considered to have converged.nonenone
rel-limitfloatnonenone

relative-convergence-measure

Relative convergence criterion based on the relative two-norm difference of data values between iterations. $$\frac{\left\lVert H(x^k) - x^k \right\rVert_2}{\left\lVert H(x^k) \right\rVert_2} < \text{limit} $$

Example:

<relative-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" limit="{float}"/>
AttributeTypeDescriptionDefaultOptions
datastringData to be measured.nonenone
meshstringMesh holding the data.nonenone
sufficesbooleanIf true, convergence of this measure is sufficient for overall convergence.falsenone
strictbooleanIf true, non-convergence of this measure ends the simulation. “strict” overrules “suffices”.falsenone
limitfloatLimit under which the measure is considered to have converged. Must be in \((0, 1]\).nonenone

residual-relative-convergence-measure

Relative convergence criterion comparing the currently measured residual to the residual of the first iteration in the time window. $$\frac{\left\lVert H(x^k) - x^k \right\rVert_2}{\left\lVert H(x^0) - x^0 \right\rVert_2} < \text{limit}$$

Example:

<residual-relative-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" limit="{float}"/>
AttributeTypeDescriptionDefaultOptions
datastringData to be measured.nonenone
meshstringMesh holding the data.nonenone
sufficesbooleanIf true, convergence of this measure is sufficient for overall convergence.falsenone
strictbooleanIf true, non-convergence of this measure ends the simulation. “strict” overrules “suffices”.falsenone
limitfloatLimit under which the measure is considered to have converged. Must be in ((0, 1]).nonenone

min-iterations

Allows to specify a minimum amount of iterations that must be performed per time window.

Example:

<min-iterations value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe minimum amount of iterations.nonenone

max-iterations

Allows to specify a maximum amount of iterations per time window.

Example:

<max-iterations value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe maximum value of iterations.nonenone

coupling-scheme:parallel-implicit

Parallel Implicit coupling scheme according to block Jacobi iterations (V-System). Improved implicit iterations are achieved by using a acceleration (recommended!).

Example:

<coupling-scheme:parallel-implicit>
  <max-time value="{float}"/>
  <max-time-windows value="{integer}"/>
  <time-window-size value="-1"/>
  <participants first="{string}" second="{string}"/>
  <exchange data="{string}" mesh="{string}" from="{string}" to="{string}" initialize="false" substeps="true"/>
  <acceleration:constant>
    ...
  </acceleration:constant>
  <absolute-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" limit="{float}"/>
  <absolute-or-relative-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" abs-limit="{float}" rel-limit="{float}"/>
  <relative-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" limit="{float}"/>
  <residual-relative-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" limit="{float}"/>
  <min-iterations value="{integer}"/>
  <max-iterations value="{integer}"/>
</coupling-scheme:parallel-implicit>

Valid Subtags:

max-time

Defined the end of the simulation as total time.

Example:

<max-time value="{float}"/>
AttributeTypeDescriptionDefaultOptions
valuefloatThe value of the maximum simulation time.nonenone

max-time-windows

Defined the end of the simulation as a total count of time windows.

Example:

<max-time-windows value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe maximum count of time windows.nonenone

time-window-size

Defines the size of the time window.

Example:

<time-window-size value="-1"/>
AttributeTypeDescriptionDefaultOptions
valuefloatThe maximum time window size.-1none

participants

Defines the participants of the coupling scheme.

Example:

<participants first="{string}" second="{string}"/>
AttributeTypeDescriptionDefaultOptions
firststringFirst participant to run the solver.nonenone
secondstringSecond participant to run the solver.nonenone

exchange

Defines the flow of data between meshes of participants.

Example:

<exchange data="{string}" mesh="{string}" from="{string}" to="{string}" initialize="false" substeps="true"/>
AttributeTypeDescriptionDefaultOptions
datastringThe data to exchange.nonenone
meshstringThe mesh which uses the data.nonenone
fromstringThe participant sending the data.nonenone
tostringThe participant receiving the data.nonenone
initializebooleanShould this data be initialized during initialize?falsenone
substepsbooleanShould this data exchange substeps?truenone

acceleration:constant

Accelerates coupling data with constant underrelaxation.

Example:

<acceleration:constant>
  <relaxation value="{float}"/>
</acceleration:constant>

Valid Subtags:

relaxation

Example:

<relaxation value="{float}"/>
AttributeTypeDescriptionDefaultOptions
valuefloatConstant relaxation factor.nonenone

acceleration:aitken

Accelerates coupling data with dynamic Aitken under-relaxation.

Example:

<acceleration:aitken>
  <initial-relaxation value="{float}"/>
  <data scaling="1" name="{string}" mesh="{string}"/>
  <preconditioner type="{string}" freeze-after="-1"/>
</acceleration:aitken>

Valid Subtags:

initial-relaxation

Initial relaxation factor. If this tag is not provided, an initial relaxation of 0.5 is used.

Example:

<initial-relaxation value="{float}"/>
AttributeTypeDescriptionDefaultOptions
valuefloatInitial relaxation factor.nonenone

data

The data used to compute the acceleration.

Example:

<data scaling="1" name="{string}" mesh="{string}"/>
AttributeTypeDescriptionDefaultOptions
scalingfloatTo improve the performance of a parallel or a multi coupling schemes, each data set can be manually scaled using this scaling factor with preconditioner type = “constant”. For all other preconditioner types, the factor is ignored. We recommend, however, to use an automatic scaling via a preconditioner.1none
namestringThe name of the data.nonenone
meshstringThe name of the mesh which holds the data.nonenone

preconditioner

To improve the numerical stability of multiple data vectors a preconditioner can be applied. A constant preconditioner scales every acceleration data by a constant value, which you can define as an attribute of data. A value preconditioner scales every acceleration data by the norm of the data in the previous time window. A residual preconditioner scales every acceleration data by the current residual. A residual-sum preconditioner scales every acceleration data by the sum of the residuals from the current time window.

Example:

<preconditioner type="{string}" freeze-after="-1"/>
AttributeTypeDescriptionDefaultOptions
typestringThe type of the preconditioner.noneconstant, value, residual, residual-sum
freeze-afterintegerAfter the given number of time windows, the preconditioner weights are frozen and the preconditioner acts like a constant preconditioner.-1none

acceleration:IQN-ILS

Accelerates coupling data with the interface quasi-Newton inverse least-squares method.

Example:

<acceleration:IQN-ILS reduced-time-grid="true" on-bound-violation="ignore">
  <initial-relaxation value="{float}" enforce="false"/>
  <max-used-iterations value="{integer}"/>
  <time-windows-reused value="{integer}"/>
  <data name="{string}" mesh="{string}" scaling="1"/>
  <filter limit="1e-16" type="QR3"/>
  <preconditioner type="{string}" update-on-threshold="true" freeze-after="-1"/>
</acceleration:IQN-ILS>
AttributeTypeDescriptionDefaultOptions
reduced-time-gridbooleanWhether only the last time step of each time window is used to construct the Jacobian.truenone
on-bound-violationstringDefines the strategy to handle updates that violate variable bounds. Use ignore when no special handling is desired. Use clamp to limit the violating components to their bounds. Use discard to skip the QN update when a bound violation occurs. Use scale to scale the QN step with a constant to fit all violating components into the bounds.ignoreignore, clamp, discard, scale

Valid Subtags:

initial-relaxation

Initial relaxation factor. If this tag is not provided, an initial relaxation of 0.1 is used.

Example:

<initial-relaxation value="{float}" enforce="false"/>
AttributeTypeDescriptionDefaultOptions
valuefloatInitial relaxation factor.nonenone
enforcebooleanEnforce initial relaxation in every time window.falsenone

max-used-iterations

Maximum number of columns used in low-rank approximation of Jacobian. If this tag is not provided, the attribute value of 100 is used.

Example:

<max-used-iterations value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe number of columns.nonenone

time-windows-reused

Number of past time windows from which columns are used to approximate Jacobian. If this tag is not provided, the default attribute value of 10 is used.

Example:

<time-windows-reused value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe number of time windows.nonenone

data

The data used to compute the acceleration.

Example:

<data name="{string}" mesh="{string}" scaling="1"/>
AttributeTypeDescriptionDefaultOptions
namestringThe name of the data.nonenone
meshstringThe name of the mesh which holds the data.nonenone
scalingfloatTo improve the performance of a parallel or a multi coupling schemes, each data set can be manually scaled using this scaling factor with preconditioner type = “constant”. For all other preconditioner types, the factor is ignored. We recommend, however, to use an automatic scaling via a preconditioner.1none

filter

Type of filtering technique that is used to maintain good conditioning in the least-squares system. Possible filters:

  • QR1: update QR-dec with (relative) test \(R(i,i) < \epsilon *\lVert R\rVert_F\)

  • QR1-absolute: update QR-dec with (absolute) test \(R(i, i) < \epsilon\)

  • QR2: en-block QR-dec with test \(\lVert v_\text{orth} \rVert_2 < \epsilon * \lVert v \rVert_2\)

  • QR3: update QR-dec only when the pre-scaling weights have changed or there is one or more columns are to be removed with test \(\lVert v_\text{orth} \rVert_2 < \epsilon * \lVert v \rVert_2\)

Please note that a QR1 is based on Given’s rotations whereas QR2 uses modified Gram-Schmidt. This can give different results even when no columns are filtered out.

Example:

<filter limit="1e-16" type="QR3"/>
AttributeTypeDescriptionDefaultOptions
limitfloatLimit eps of the filter.1e-16none
typestringType of the filter.QR3QR1, QR1-absolute, QR2, QR3

preconditioner

To improve the performance of a parallel or a multi coupling schemes a preconditioner can be applied.

  • A constant preconditioner scales every acceleration data by a constant value, which you can define as an attribute of data.
  • A value preconditioner scales every acceleration data by the norm of the data in the previous time window.
  • A residual preconditioner scales every acceleration data by the current residual.
  • A residual-sum preconditioner scales every acceleration data by the sum of the residuals from the current time window.

If this tag is not provided, the residual-sum preconditioner is employed.

Example:

<preconditioner type="{string}" update-on-threshold="true" freeze-after="-1"/>
AttributeTypeDescriptionDefaultOptions
typestringThe type of the preconditioner.noneconstant, value, residual, residual-sum
update-on-thresholdbooleanTo update the preconditioner weights after the first time window: true: The preconditioner weights are only updated if the weights will change by more than one order of magnitude. false: The preconditioner weights are updated after every iteration.truenone
freeze-afterintegerAfter the given number of time windows, the preconditioner weights are frozen and the preconditioner acts like a constant preconditioner.-1none

acceleration:IQN-IMVJ

Accelerates coupling data with the interface quasi-Newton inverse multi-vector Jacobian method.

Example:

<acceleration:IQN-IMVJ always-build-jacobian="false" reduced-time-grid="true" on-bound-violation="ignore">
  <initial-relaxation value="{float}" enforce="false"/>
  <imvj-restart-mode type="RS-SVD" chunk-size="8" reused-time-windows-at-restart="8" truncation-threshold="0.0001"/>
  <max-used-iterations value="{integer}"/>
  <time-windows-reused value="{integer}"/>
  <data name="{string}" mesh="{string}" scaling="1"/>
  <filter limit="1e-16" type="QR3"/>
  <preconditioner type="{string}" update-on-threshold="true" freeze-after="-1"/>
</acceleration:IQN-IMVJ>
AttributeTypeDescriptionDefaultOptions
always-build-jacobianbooleanIf set to true, the IMVJ will set up the Jacobian matrix in each coupling iteration, which is inefficient. If set to false (or not set) the Jacobian is only build in the last iteration and the updates are computed using (relatively) cheap MATVEC products.falsenone
reduced-time-gridbooleanWhether only the last time step of each time window is used to construct the Jacobian.truenone
on-bound-violationstringDefines the strategy to handle updates that violate variable bounds. Use ignore when no special handling is desired. Use clamp to limit the violating components to their bounds. Use discard to skip the QN update when a bound violation occurs. Use scale to scale the QN step with a constant to fit all violating components into the bounds.ignoreignore, clamp, discard, scale

Valid Subtags:

initial-relaxation

Initial relaxation factor. If this tag is not provided, an initial relaxation of 0.1 is used.

Example:

<initial-relaxation value="{float}" enforce="false"/>
AttributeTypeDescriptionDefaultOptions
valuefloatInitial relaxation factor.nonenone
enforcebooleanEnforce initial relaxation in every time window.falsenone

imvj-restart-mode

Enable IMVJ Type of IMVJ restart mode that is used: no-restart: IMVJ runs in normal mode with explicit representation of Jacobian. RS-0: IMVJ runs in restart mode. After M time windows all Jacobain information is dropped, restart with no information. RS-LS: IMVJ runs in restart mode. After M time windows a IQN-LS like approximation for the initial guess of the Jacobian is computed. RS-SVD: IMVJ runs in restart mode. After M time windows a truncated SVD of the Jacobian is updated. RS-SLIDE: IMVJ runs in sliding window restart mode. If this tag is not provided, IMVJ runs in restart mode with SVD-method.

Example:

<imvj-restart-mode type="RS-SVD" chunk-size="8" reused-time-windows-at-restart="8" truncation-threshold="0.0001"/>
AttributeTypeDescriptionDefaultOptions
typestringType of the restart mode.RS-SVDno-restart, RS-0, RS-LS, RS-SVD, RS-SLIDE
chunk-sizeintegerSpecifies the number of time windows M after which the IMVJ restarts, if run in restart-mode. Default value is M=8.8none
reused-time-windows-at-restartintegerIf IMVJ restart-mode=RS-LS, the number of reused time windows at restart can be specified.8none
truncation-thresholdfloatIf IMVJ restart-mode=RS-SVD, the truncation threshold for the updated SVD can be set.0.0001none

max-used-iterations

Maximum number of columns used in low-rank approximation of Jacobian. If this tag is not provided, the default attribute value of 20 is used.

Example:

<max-used-iterations value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe number of columns.nonenone

time-windows-reused

Number of past time windows from which columns are used to approximate Jacobian. If this tag is not provided, the attribute value of 0 is used.

Example:

<time-windows-reused value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe number of columns.nonenone

data

The data used to compute the acceleration.

Example:

<data name="{string}" mesh="{string}" scaling="1"/>
AttributeTypeDescriptionDefaultOptions
namestringThe name of the data.nonenone
meshstringThe name of the mesh which holds the data.nonenone
scalingfloatTo improve the performance of a parallel or a multi coupling schemes, each data set can be manually scaled using this scaling factor with preconditioner type = “constant”. For all other preconditioner types, the factor is ignored. We recommend, however, to use an automatic scaling via a preconditioner.1none

filter

Type of filtering technique that is used to maintain good conditioning in the least-squares system. Possible filters:

  • QR1: update QR-dec with (relative) test \(R(i,i) < \epsilon *\lVert R\rVert_F\)

  • QR1-absolute: update QR-dec with (absolute) test \(R(i, i) < \epsilon\)

  • QR2: en-block QR-dec with test \(\lVert v_\text{orth} \rVert_2 < \epsilon * \lVert v \rVert_2\)

  • QR3: update QR-dec only when the pre-scaling weights have changed or there is one or more columns are to be removed with test \(\lVert v_\text{orth} \rVert_2 < \epsilon * \lVert v \rVert_2\)

Please note that a QR1 is based on Given’s rotations whereas QR2 uses modified Gram-Schmidt. This can give different results even when no columns are filtered out.

Example:

<filter limit="1e-16" type="QR3"/>
AttributeTypeDescriptionDefaultOptions
limitfloatLimit eps of the filter.1e-16none
typestringType of the filter.QR3QR1, QR1-absolute, QR2, QR3

preconditioner

To improve the performance of a parallel or a multi coupling schemes a preconditioner can be applied.

  • A constant preconditioner scales every acceleration data by a constant value, which you can define as an attribute of data.
  • A value preconditioner scales every acceleration data by the norm of the data in the previous time window.
  • A residual preconditioner scales every acceleration data by the current residual.
  • A residual-sum preconditioner scales every acceleration data by the sum of the residuals from the current time window.

If this tag is not provided, the residual-sum preconditioner is employed.

Example:

<preconditioner type="{string}" update-on-threshold="true" freeze-after="-1"/>
AttributeTypeDescriptionDefaultOptions
typestringType of the preconditioner.noneconstant, value, residual, residual-sum
update-on-thresholdbooleanTo update the preconditioner weights after the first time window: true: The preconditioner weights are only updated if the weights will change by more than one order of magnitude. false: The preconditioner weights are updated after every iteration.truenone
freeze-afterintegerAfter the given number of time windows, the preconditioner weights are frozen and the preconditioner acts like a constant preconditioner.-1none

absolute-convergence-measure

Absolute convergence criterion based on the two-norm difference of data values between iterations. $$\left\lVert H(x^k) - x^k \right\rVert_2 < \text{limit}$$

Example:

<absolute-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" limit="{float}"/>
AttributeTypeDescriptionDefaultOptions
datastringData to be measured.nonenone
meshstringMesh holding the data.nonenone
sufficesbooleanIf true, convergence of this measure is sufficient for overall convergence.falsenone
strictbooleanIf true, non-convergence of this measure ends the simulation. “strict” overrules “suffices”.falsenone
limitfloatLimit under which the measure is considered to have converged. Must be in ((0, 1]).nonenone

absolute-or-relative-convergence-measure

Absolute or relative convergence, which is the disjunction of an absolute criterion based on the two-norm difference of data values between iterations and a relative criterion based on the relative two-norm difference of data values between iterations,i.e. convergence is reached as soon as one of the both criteria is fulfilled. $$\left\lVert H(x^k) - x^k \right\rVert_2 < \text{abs-limit}\quad\text{or}\quad\frac{\left\lVert H(x^k) - x^k \right\rVert_2}{\left\lVert H(x^k) \right\rVert_2} < \text{rel-limit} $$

Example:

<absolute-or-relative-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" abs-limit="{float}" rel-limit="{float}"/>
AttributeTypeDescriptionDefaultOptions
datastringData to be measured.nonenone
meshstringMesh holding the data.nonenone
sufficesbooleanIf true, convergence of this measure is sufficient for overall convergence.falsenone
strictbooleanIf true, non-convergence of this measure ends the simulation. “strict” overrules “suffices”.falsenone
abs-limitfloatAbsolute limit under which the measure is considered to have converged.nonenone
rel-limitfloatnonenone

relative-convergence-measure

Relative convergence criterion based on the relative two-norm difference of data values between iterations. $$\frac{\left\lVert H(x^k) - x^k \right\rVert_2}{\left\lVert H(x^k) \right\rVert_2} < \text{limit} $$

Example:

<relative-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" limit="{float}"/>
AttributeTypeDescriptionDefaultOptions
datastringData to be measured.nonenone
meshstringMesh holding the data.nonenone
sufficesbooleanIf true, convergence of this measure is sufficient for overall convergence.falsenone
strictbooleanIf true, non-convergence of this measure ends the simulation. “strict” overrules “suffices”.falsenone
limitfloatLimit under which the measure is considered to have converged. Must be in \((0, 1]\).nonenone

residual-relative-convergence-measure

Relative convergence criterion comparing the currently measured residual to the residual of the first iteration in the time window. $$\frac{\left\lVert H(x^k) - x^k \right\rVert_2}{\left\lVert H(x^0) - x^0 \right\rVert_2} < \text{limit}$$

Example:

<residual-relative-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" limit="{float}"/>
AttributeTypeDescriptionDefaultOptions
datastringData to be measured.nonenone
meshstringMesh holding the data.nonenone
sufficesbooleanIf true, convergence of this measure is sufficient for overall convergence.falsenone
strictbooleanIf true, non-convergence of this measure ends the simulation. “strict” overrules “suffices”.falsenone
limitfloatLimit under which the measure is considered to have converged. Must be in ((0, 1]).nonenone

min-iterations

Allows to specify a minimum amount of iterations that must be performed per time window.

Example:

<min-iterations value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe minimum amount of iterations.nonenone

max-iterations

Allows to specify a maximum amount of iterations per time window.

Example:

<max-iterations value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe maximum value of iterations.nonenone

coupling-scheme:multi

Multi coupling scheme according to block Jacobi iterations. Improved implicit iterations are achieved by using a acceleration (recommended!).

Example:

<coupling-scheme:multi>
  <max-time value="{float}"/>
  <max-time-windows value="{integer}"/>
  <time-window-size value="-1"/>
  <participant name="{string}" control="false"/>
  <exchange data="{string}" mesh="{string}" from="{string}" to="{string}" initialize="false" substeps="true"/>
  <acceleration:constant>
    ...
  </acceleration:constant>
  <absolute-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" limit="{float}"/>
  <absolute-or-relative-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" abs-limit="{float}" rel-limit="{float}"/>
  <relative-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" limit="{float}"/>
  <residual-relative-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" limit="{float}"/>
  <min-iterations value="{integer}"/>
  <max-iterations value="{integer}"/>
</coupling-scheme:multi>

Valid Subtags:

max-time

Defined the end of the simulation as total time.

Example:

<max-time value="{float}"/>
AttributeTypeDescriptionDefaultOptions
valuefloatThe value of the maximum simulation time.nonenone

max-time-windows

Defined the end of the simulation as a total count of time windows.

Example:

<max-time-windows value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe maximum count of time windows.nonenone

time-window-size

Defines the size of the time window.

Example:

<time-window-size value="-1"/>
AttributeTypeDescriptionDefaultOptions
valuefloatThe maximum time window size.-1none

participant

Example:

<participant name="{string}" control="false"/>
AttributeTypeDescriptionDefaultOptions
namestringName of the participant.nonenone
controlbooleanDoes this participant control the coupling?falsenone

exchange

Defines the flow of data between meshes of participants.

Example:

<exchange data="{string}" mesh="{string}" from="{string}" to="{string}" initialize="false" substeps="true"/>
AttributeTypeDescriptionDefaultOptions
datastringThe data to exchange.nonenone
meshstringThe mesh which uses the data.nonenone
fromstringThe participant sending the data.nonenone
tostringThe participant receiving the data.nonenone
initializebooleanShould this data be initialized during initialize?falsenone
substepsbooleanShould this data exchange substeps?truenone

acceleration:constant

Accelerates coupling data with constant underrelaxation.

Example:

<acceleration:constant>
  <relaxation value="{float}"/>
</acceleration:constant>

Valid Subtags:

relaxation

Example:

<relaxation value="{float}"/>
AttributeTypeDescriptionDefaultOptions
valuefloatConstant relaxation factor.nonenone

acceleration:aitken

Accelerates coupling data with dynamic Aitken under-relaxation.

Example:

<acceleration:aitken>
  <initial-relaxation value="{float}"/>
  <data scaling="1" name="{string}" mesh="{string}"/>
  <preconditioner type="{string}" freeze-after="-1"/>
</acceleration:aitken>

Valid Subtags:

initial-relaxation

Initial relaxation factor. If this tag is not provided, an initial relaxation of 0.5 is used.

Example:

<initial-relaxation value="{float}"/>
AttributeTypeDescriptionDefaultOptions
valuefloatInitial relaxation factor.nonenone

data

The data used to compute the acceleration.

Example:

<data scaling="1" name="{string}" mesh="{string}"/>
AttributeTypeDescriptionDefaultOptions
scalingfloatTo improve the performance of a parallel or a multi coupling schemes, each data set can be manually scaled using this scaling factor with preconditioner type = “constant”. For all other preconditioner types, the factor is ignored. We recommend, however, to use an automatic scaling via a preconditioner.1none
namestringThe name of the data.nonenone
meshstringThe name of the mesh which holds the data.nonenone

preconditioner

To improve the numerical stability of multiple data vectors a preconditioner can be applied. A constant preconditioner scales every acceleration data by a constant value, which you can define as an attribute of data. A value preconditioner scales every acceleration data by the norm of the data in the previous time window. A residual preconditioner scales every acceleration data by the current residual. A residual-sum preconditioner scales every acceleration data by the sum of the residuals from the current time window.

Example:

<preconditioner type="{string}" freeze-after="-1"/>
AttributeTypeDescriptionDefaultOptions
typestringThe type of the preconditioner.noneconstant, value, residual, residual-sum
freeze-afterintegerAfter the given number of time windows, the preconditioner weights are frozen and the preconditioner acts like a constant preconditioner.-1none

acceleration:IQN-ILS

Accelerates coupling data with the interface quasi-Newton inverse least-squares method.

Example:

<acceleration:IQN-ILS reduced-time-grid="true" on-bound-violation="ignore">
  <initial-relaxation value="{float}" enforce="false"/>
  <max-used-iterations value="{integer}"/>
  <time-windows-reused value="{integer}"/>
  <data name="{string}" mesh="{string}" scaling="1"/>
  <filter limit="1e-16" type="QR3"/>
  <preconditioner type="{string}" update-on-threshold="true" freeze-after="-1"/>
</acceleration:IQN-ILS>
AttributeTypeDescriptionDefaultOptions
reduced-time-gridbooleanWhether only the last time step of each time window is used to construct the Jacobian.truenone
on-bound-violationstringDefines the strategy to handle updates that violate variable bounds. Use ignore when no special handling is desired. Use clamp to limit the violating components to their bounds. Use discard to skip the QN update when a bound violation occurs. Use scale to scale the QN step with a constant to fit all violating components into the bounds.ignoreignore, clamp, discard, scale

Valid Subtags:

initial-relaxation

Initial relaxation factor. If this tag is not provided, an initial relaxation of 0.1 is used.

Example:

<initial-relaxation value="{float}" enforce="false"/>
AttributeTypeDescriptionDefaultOptions
valuefloatInitial relaxation factor.nonenone
enforcebooleanEnforce initial relaxation in every time window.falsenone

max-used-iterations

Maximum number of columns used in low-rank approximation of Jacobian. If this tag is not provided, the attribute value of 100 is used.

Example:

<max-used-iterations value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe number of columns.nonenone

time-windows-reused

Number of past time windows from which columns are used to approximate Jacobian. If this tag is not provided, the default attribute value of 10 is used.

Example:

<time-windows-reused value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe number of time windows.nonenone

data

The data used to compute the acceleration.

Example:

<data name="{string}" mesh="{string}" scaling="1"/>
AttributeTypeDescriptionDefaultOptions
namestringThe name of the data.nonenone
meshstringThe name of the mesh which holds the data.nonenone
scalingfloatTo improve the performance of a parallel or a multi coupling schemes, each data set can be manually scaled using this scaling factor with preconditioner type = “constant”. For all other preconditioner types, the factor is ignored. We recommend, however, to use an automatic scaling via a preconditioner.1none

filter

Type of filtering technique that is used to maintain good conditioning in the least-squares system. Possible filters:

  • QR1: update QR-dec with (relative) test \(R(i,i) < \epsilon *\lVert R\rVert_F\)

  • QR1-absolute: update QR-dec with (absolute) test \(R(i, i) < \epsilon\)

  • QR2: en-block QR-dec with test \(\lVert v_\text{orth} \rVert_2 < \epsilon * \lVert v \rVert_2\)

  • QR3: update QR-dec only when the pre-scaling weights have changed or there is one or more columns are to be removed with test \(\lVert v_\text{orth} \rVert_2 < \epsilon * \lVert v \rVert_2\)

Please note that a QR1 is based on Given’s rotations whereas QR2 uses modified Gram-Schmidt. This can give different results even when no columns are filtered out.

Example:

<filter limit="1e-16" type="QR3"/>
AttributeTypeDescriptionDefaultOptions
limitfloatLimit eps of the filter.1e-16none
typestringType of the filter.QR3QR1, QR1-absolute, QR2, QR3

preconditioner

To improve the performance of a parallel or a multi coupling schemes a preconditioner can be applied.

  • A constant preconditioner scales every acceleration data by a constant value, which you can define as an attribute of data.
  • A value preconditioner scales every acceleration data by the norm of the data in the previous time window.
  • A residual preconditioner scales every acceleration data by the current residual.
  • A residual-sum preconditioner scales every acceleration data by the sum of the residuals from the current time window.

If this tag is not provided, the residual-sum preconditioner is employed.

Example:

<preconditioner type="{string}" update-on-threshold="true" freeze-after="-1"/>
AttributeTypeDescriptionDefaultOptions
typestringThe type of the preconditioner.noneconstant, value, residual, residual-sum
update-on-thresholdbooleanTo update the preconditioner weights after the first time window: true: The preconditioner weights are only updated if the weights will change by more than one order of magnitude. false: The preconditioner weights are updated after every iteration.truenone
freeze-afterintegerAfter the given number of time windows, the preconditioner weights are frozen and the preconditioner acts like a constant preconditioner.-1none

acceleration:IQN-IMVJ

Accelerates coupling data with the interface quasi-Newton inverse multi-vector Jacobian method.

Example:

<acceleration:IQN-IMVJ always-build-jacobian="false" reduced-time-grid="true" on-bound-violation="ignore">
  <initial-relaxation value="{float}" enforce="false"/>
  <imvj-restart-mode type="RS-SVD" chunk-size="8" reused-time-windows-at-restart="8" truncation-threshold="0.0001"/>
  <max-used-iterations value="{integer}"/>
  <time-windows-reused value="{integer}"/>
  <data name="{string}" mesh="{string}" scaling="1"/>
  <filter limit="1e-16" type="QR3"/>
  <preconditioner type="{string}" update-on-threshold="true" freeze-after="-1"/>
</acceleration:IQN-IMVJ>
AttributeTypeDescriptionDefaultOptions
always-build-jacobianbooleanIf set to true, the IMVJ will set up the Jacobian matrix in each coupling iteration, which is inefficient. If set to false (or not set) the Jacobian is only build in the last iteration and the updates are computed using (relatively) cheap MATVEC products.falsenone
reduced-time-gridbooleanWhether only the last time step of each time window is used to construct the Jacobian.truenone
on-bound-violationstringDefines the strategy to handle updates that violate variable bounds. Use ignore when no special handling is desired. Use clamp to limit the violating components to their bounds. Use discard to skip the QN update when a bound violation occurs. Use scale to scale the QN step with a constant to fit all violating components into the bounds.ignoreignore, clamp, discard, scale

Valid Subtags:

initial-relaxation

Initial relaxation factor. If this tag is not provided, an initial relaxation of 0.1 is used.

Example:

<initial-relaxation value="{float}" enforce="false"/>
AttributeTypeDescriptionDefaultOptions
valuefloatInitial relaxation factor.nonenone
enforcebooleanEnforce initial relaxation in every time window.falsenone

imvj-restart-mode

Enable IMVJ Type of IMVJ restart mode that is used: no-restart: IMVJ runs in normal mode with explicit representation of Jacobian. RS-0: IMVJ runs in restart mode. After M time windows all Jacobain information is dropped, restart with no information. RS-LS: IMVJ runs in restart mode. After M time windows a IQN-LS like approximation for the initial guess of the Jacobian is computed. RS-SVD: IMVJ runs in restart mode. After M time windows a truncated SVD of the Jacobian is updated. RS-SLIDE: IMVJ runs in sliding window restart mode. If this tag is not provided, IMVJ runs in restart mode with SVD-method.

Example:

<imvj-restart-mode type="RS-SVD" chunk-size="8" reused-time-windows-at-restart="8" truncation-threshold="0.0001"/>
AttributeTypeDescriptionDefaultOptions
typestringType of the restart mode.RS-SVDno-restart, RS-0, RS-LS, RS-SVD, RS-SLIDE
chunk-sizeintegerSpecifies the number of time windows M after which the IMVJ restarts, if run in restart-mode. Default value is M=8.8none
reused-time-windows-at-restartintegerIf IMVJ restart-mode=RS-LS, the number of reused time windows at restart can be specified.8none
truncation-thresholdfloatIf IMVJ restart-mode=RS-SVD, the truncation threshold for the updated SVD can be set.0.0001none

max-used-iterations

Maximum number of columns used in low-rank approximation of Jacobian. If this tag is not provided, the default attribute value of 20 is used.

Example:

<max-used-iterations value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe number of columns.nonenone

time-windows-reused

Number of past time windows from which columns are used to approximate Jacobian. If this tag is not provided, the attribute value of 0 is used.

Example:

<time-windows-reused value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe number of columns.nonenone

data

The data used to compute the acceleration.

Example:

<data name="{string}" mesh="{string}" scaling="1"/>
AttributeTypeDescriptionDefaultOptions
namestringThe name of the data.nonenone
meshstringThe name of the mesh which holds the data.nonenone
scalingfloatTo improve the performance of a parallel or a multi coupling schemes, each data set can be manually scaled using this scaling factor with preconditioner type = “constant”. For all other preconditioner types, the factor is ignored. We recommend, however, to use an automatic scaling via a preconditioner.1none

filter

Type of filtering technique that is used to maintain good conditioning in the least-squares system. Possible filters:

  • QR1: update QR-dec with (relative) test \(R(i,i) < \epsilon *\lVert R\rVert_F\)

  • QR1-absolute: update QR-dec with (absolute) test \(R(i, i) < \epsilon\)

  • QR2: en-block QR-dec with test \(\lVert v_\text{orth} \rVert_2 < \epsilon * \lVert v \rVert_2\)

  • QR3: update QR-dec only when the pre-scaling weights have changed or there is one or more columns are to be removed with test \(\lVert v_\text{orth} \rVert_2 < \epsilon * \lVert v \rVert_2\)

Please note that a QR1 is based on Given’s rotations whereas QR2 uses modified Gram-Schmidt. This can give different results even when no columns are filtered out.

Example:

<filter limit="1e-16" type="QR3"/>
AttributeTypeDescriptionDefaultOptions
limitfloatLimit eps of the filter.1e-16none
typestringType of the filter.QR3QR1, QR1-absolute, QR2, QR3

preconditioner

To improve the performance of a parallel or a multi coupling schemes a preconditioner can be applied.

  • A constant preconditioner scales every acceleration data by a constant value, which you can define as an attribute of data.
  • A value preconditioner scales every acceleration data by the norm of the data in the previous time window.
  • A residual preconditioner scales every acceleration data by the current residual.
  • A residual-sum preconditioner scales every acceleration data by the sum of the residuals from the current time window.

If this tag is not provided, the residual-sum preconditioner is employed.

Example:

<preconditioner type="{string}" update-on-threshold="true" freeze-after="-1"/>
AttributeTypeDescriptionDefaultOptions
typestringType of the preconditioner.noneconstant, value, residual, residual-sum
update-on-thresholdbooleanTo update the preconditioner weights after the first time window: true: The preconditioner weights are only updated if the weights will change by more than one order of magnitude. false: The preconditioner weights are updated after every iteration.truenone
freeze-afterintegerAfter the given number of time windows, the preconditioner weights are frozen and the preconditioner acts like a constant preconditioner.-1none

absolute-convergence-measure

Absolute convergence criterion based on the two-norm difference of data values between iterations. $$\left\lVert H(x^k) - x^k \right\rVert_2 < \text{limit}$$

Example:

<absolute-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" limit="{float}"/>
AttributeTypeDescriptionDefaultOptions
datastringData to be measured.nonenone
meshstringMesh holding the data.nonenone
sufficesbooleanIf true, convergence of this measure is sufficient for overall convergence.falsenone
strictbooleanIf true, non-convergence of this measure ends the simulation. “strict” overrules “suffices”.falsenone
limitfloatLimit under which the measure is considered to have converged. Must be in ((0, 1]).nonenone

absolute-or-relative-convergence-measure

Absolute or relative convergence, which is the disjunction of an absolute criterion based on the two-norm difference of data values between iterations and a relative criterion based on the relative two-norm difference of data values between iterations,i.e. convergence is reached as soon as one of the both criteria is fulfilled. $$\left\lVert H(x^k) - x^k \right\rVert_2 < \text{abs-limit}\quad\text{or}\quad\frac{\left\lVert H(x^k) - x^k \right\rVert_2}{\left\lVert H(x^k) \right\rVert_2} < \text{rel-limit} $$

Example:

<absolute-or-relative-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" abs-limit="{float}" rel-limit="{float}"/>
AttributeTypeDescriptionDefaultOptions
datastringData to be measured.nonenone
meshstringMesh holding the data.nonenone
sufficesbooleanIf true, convergence of this measure is sufficient for overall convergence.falsenone
strictbooleanIf true, non-convergence of this measure ends the simulation. “strict” overrules “suffices”.falsenone
abs-limitfloatAbsolute limit under which the measure is considered to have converged.nonenone
rel-limitfloatnonenone

relative-convergence-measure

Relative convergence criterion based on the relative two-norm difference of data values between iterations. $$\frac{\left\lVert H(x^k) - x^k \right\rVert_2}{\left\lVert H(x^k) \right\rVert_2} < \text{limit} $$

Example:

<relative-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" limit="{float}"/>
AttributeTypeDescriptionDefaultOptions
datastringData to be measured.nonenone
meshstringMesh holding the data.nonenone
sufficesbooleanIf true, convergence of this measure is sufficient for overall convergence.falsenone
strictbooleanIf true, non-convergence of this measure ends the simulation. “strict” overrules “suffices”.falsenone
limitfloatLimit under which the measure is considered to have converged. Must be in \((0, 1]\).nonenone

residual-relative-convergence-measure

Relative convergence criterion comparing the currently measured residual to the residual of the first iteration in the time window. $$\frac{\left\lVert H(x^k) - x^k \right\rVert_2}{\left\lVert H(x^0) - x^0 \right\rVert_2} < \text{limit}$$

Example:

<residual-relative-convergence-measure data="{string}" mesh="{string}" suffices="false" strict="false" limit="{float}"/>
AttributeTypeDescriptionDefaultOptions
datastringData to be measured.nonenone
meshstringMesh holding the data.nonenone
sufficesbooleanIf true, convergence of this measure is sufficient for overall convergence.falsenone
strictbooleanIf true, non-convergence of this measure ends the simulation. “strict” overrules “suffices”.falsenone
limitfloatLimit under which the measure is considered to have converged. Must be in ((0, 1]).nonenone

min-iterations

Allows to specify a minimum amount of iterations that must be performed per time window.

Example:

<min-iterations value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe minimum amount of iterations.nonenone

max-iterations

Allows to specify a maximum amount of iterations per time window.

Example:

<max-iterations value="{integer}"/>
AttributeTypeDescriptionDefaultOptions
valueintegerThe maximum value of iterations.nonenone