#coding: utf8
"""
Data flow classes for standard properties.

This module contains providers, receivers, and filters for standard properties.
These classes are present in binary solvers, but you may also use them in your
custom Python solvers.

.. rubric:: Providers and Receivers

Existing providers can be connected to receivers by using a simple assignment
operator:

>>> first_solver.inTemperature = second_solver.outTemperature

You can manually retrieve data from any provider or a connected receiver by
calling it like a function:

>>> second_solver.outTemperature(mymesh)
<plask.Data at 0x584c140>
>>> first_solver.inTemperature(mymesh, 'spline')
<plask.Data at 0x584c140>

Providers and receivers of most quantities give spatial distributions of the
corresponding fields and, thus, require the target mesh as its argument. In
addition you may specify the interpolation method as in the example above.
If the interpolation method is omitted, its default value, depending is assumed
by the solver automatically.

Some properties (e.g. the light intensity) require the result number given as
the first argument (this is e.g. the consecutive mode number). Others take some
optional arguments that are specified at the end (e.g. the gain requires to be
given the wavelength at which the gain is computed.

In PLaSK you can create your custom Python solvers. They may contain the default
providers and receivers defined here. Receivers are simple objects that can be
attached to providers later and read as shown above. On the contrary, providers
require you to create a callable that returns the data to be provided when
requested.

Example:
   To create the solver that gets temperature from another source and
   increases it by 60 K, use the following class:

   >>> class Hotter(object):
   ...     def __init__(self):
   ...         self.inTemperature = flow.TemperatureReceiver2D()
   ...         self.outTemperature = flow.TemperatureProvider2D(
   ...             lambda mesh, meth: self.get_data(mesh, meth))
   ...     def get_data(self, mesh, method):
   ...         temp = self.inTemperature(mesh, method)
   ...         return temp.array + 60.

.. rubric:: Filters

Filters are solver-like classes that translate the fields computed in one
geometry to another one. This geometry can have either the same or different
dimension.

All filter classes are used the same way. They are constructed with a single
argument, which is a target geometry. The type of this geometry must match
the suffix of the filter (``2D`` for two-dimensional Cartesian geometry, ``Cyl``
for axi-symmetric cylindrical geometry, and ``3D`` for three-dimensional one.
An example temperature filter for target 2D geometry can be constructed as
follows:

>>> temp_filter = flow.TemperatureFilter2D(mygeometry2d)

Having an existing filter, you may attach a source provider to it, using bracket
indexing. The `index` is a geometry object either existing in the target geometry
or containing it (e.g. a :class:`geometry.Extrusion` object that is the root of
the ``my_geometry_2d`` geometry). The `indexed` element is a proper data receiver
that can be used for connecting the source data.

>>> temp_filter[some_object_in_mygeometry2d]
<plask.ReceiverForTemperature2D at 0x43a5210>
>>> temp_filter[mygeometry2d.extrusion]
<plask.ReceiverForTemperature3D at 0x44751a0>

>>> temp_filter[mygeometry2d.extrusion] = thermal_solver_3d.outTemperature

After connecting the source, the tranlated data can be obtained using the filter
member ``out``, which is a provider that can be connected to other solvers.

>>> temp_filter.out
<plask.ProviderForTemperature2D at 0x43a5fa0>
>>> other_solver_in_2d.inTemperature = temp_filter.out

After the connection the filter does its job automatically.

See also:
   :ref:`sec-solvers-filters`.

   Definition of filters in the XPL file: :xml:tag:`filter` tag.

   Example using filters: :ref:`sec-tutorial-threshold-of-array`.
"""

import plask


class BandEdgesFilter2D(plask.Solver):
    """
    BandEdgesFilter2D(geometry)
    
    Data filter for conduction and valence band edges into Cartesian2D geometry.
    
    Args:
        geometry (geometry.Cartesian2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inBandEdges = my_filter.out
    """



class BandEdgesFilter3D(plask.Solver):
    """
    BandEdgesFilter3D(geometry)
    
    Data filter for conduction and valence band edges into Cartesian3D geometry.
    
    Args:
        geometry (geometry.Cartesian3D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inBandEdges = my_filter.out
    """



class BandEdgesFilterCyl(plask.Solver):
    """
    BandEdgesFilterCyl(geometry)
    
    Data filter for conduction and valence band edges into Cylindrical2D geometry.
    
    Args:
        geometry (geometry.Cylindrical2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inBandEdges = my_filter.out
    """



class BandEdgesProvider2D(object):
    """
    BandEdgesProvider2D(data)
    
    Provider of the conduction and valence band edges in Cartesian2D geometry [eV].
    
    This class is used for conduction and valence band edges provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outBandEdges(n=0, mesh, interpolation='default')
    
       :param int n: Value number.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the conduction and valence band edges on the specified mesh **[eV]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inBandEdges = solver.outBandEdges
    
       Obtain the provided field:
    
       >>> solver.outBandEdges(0, mesh)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outBandEdges)
       3
    
    See also:
       Receiver of conduction and valence band edges: :class:`plask.flow.BandEdgesReceiver2D`
       Data filter for conduction and valence band edges: :class:`plask.flow.BandEdgesFilter2D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param int n: Value number.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class BandEdgesProvider3D(object):
    """
    BandEdgesProvider3D(data)
    
    Provider of the conduction and valence band edges in Cartesian3D geometry [eV].
    
    This class is used for conduction and valence band edges provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outBandEdges(n=0, mesh, interpolation='default')
    
       :param int n: Value number.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the conduction and valence band edges on the specified mesh **[eV]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inBandEdges = solver.outBandEdges
    
       Obtain the provided field:
    
       >>> solver.outBandEdges(0, mesh)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outBandEdges)
       3
    
    See also:
       Receiver of conduction and valence band edges: :class:`plask.flow.BandEdgesReceiver3D`
       Data filter for conduction and valence band edges: :class:`plask.flow.BandEdgesFilter3D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param int n: Value number.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class BandEdgesProviderCyl(object):
    """
    BandEdgesProviderCyl(data)
    
    Provider of the conduction and valence band edges in Cylindrical2D geometry [eV].
    
    This class is used for conduction and valence band edges provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outBandEdges(n=0, mesh, interpolation='default')
    
       :param int n: Value number.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the conduction and valence band edges on the specified mesh **[eV]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inBandEdges = solver.outBandEdges
    
       Obtain the provided field:
    
       >>> solver.outBandEdges(0, mesh)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outBandEdges)
       3
    
    See also:
       Receiver of conduction and valence band edges: :class:`plask.flow.BandEdgesReceiverCyl`
       Data filter for conduction and valence band edges: :class:`plask.flow.BandEdgesFilterCyl`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param int n: Value number.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class BandEdgesReceiver2D(object):
    """
    BandEdgesReceiver2D()
    
    Receiver of the conduction and valence band edges in Cartesian2D geometry [eV].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.BandEdgesProvider2D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inBandEdges = other_solver.outBandEdges
    
    See also:
       Provider of conduction and valence band edges: :class:`plask.flow.BandEdgesProvider2D`
    
       Data filter for conduction and valence band edges: :class:`plask.flow.BandEdgesFilter2D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inBandEdges.attach(300.)
               >>> solver.inBandEdges(any_mesh)[0]
               300.
               >>> solver.inBandEdges(any_mesh)[-1]
               300.
            
               >>> solver.inBandEdges.attach(other_solver.outBandEdges)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inBandEdges = other_solver.outBandEdges
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class BandEdgesReceiver3D(object):
    """
    BandEdgesReceiver3D()
    
    Receiver of the conduction and valence band edges in Cartesian3D geometry [eV].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.BandEdgesProvider3D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inBandEdges = other_solver.outBandEdges
    
    See also:
       Provider of conduction and valence band edges: :class:`plask.flow.BandEdgesProvider3D`
    
       Data filter for conduction and valence band edges: :class:`plask.flow.BandEdgesFilter3D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inBandEdges.attach(300.)
               >>> solver.inBandEdges(any_mesh)[0]
               300.
               >>> solver.inBandEdges(any_mesh)[-1]
               300.
            
               >>> solver.inBandEdges.attach(other_solver.outBandEdges)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inBandEdges = other_solver.outBandEdges
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class BandEdgesReceiverCyl(object):
    """
    BandEdgesReceiverCyl()
    
    Receiver of the conduction and valence band edges in Cylindrical2D geometry [eV].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.BandEdgesProviderCyl`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inBandEdges = other_solver.outBandEdges
    
    See also:
       Provider of conduction and valence band edges: :class:`plask.flow.BandEdgesProviderCyl`
    
       Data filter for conduction and valence band edges: :class:`plask.flow.BandEdgesFilterCyl`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inBandEdges.attach(300.)
               >>> solver.inBandEdges(any_mesh)[0]
               300.
               >>> solver.inBandEdges(any_mesh)[-1]
               300.
            
               >>> solver.inBandEdges.attach(other_solver.outBandEdges)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inBandEdges = other_solver.outBandEdges
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class CarriersConcentrationFilter2D(plask.Solver):
    """
    CarriersConcentrationFilter2D(geometry)
    
    Data filter for carriers concentration into Cartesian2D geometry.
    
    Args:
        geometry (geometry.Cartesian2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inCarriersConcentration = my_filter.out
    """



class CarriersConcentrationFilter3D(plask.Solver):
    """
    CarriersConcentrationFilter3D(geometry)
    
    Data filter for carriers concentration into Cartesian3D geometry.
    
    Args:
        geometry (geometry.Cartesian3D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inCarriersConcentration = my_filter.out
    """



class CarriersConcentrationFilterCyl(plask.Solver):
    """
    CarriersConcentrationFilterCyl(geometry)
    
    Data filter for carriers concentration into Cylindrical2D geometry.
    
    Args:
        geometry (geometry.Cylindrical2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inCarriersConcentration = my_filter.out
    """



class CarriersConcentrationProvider2D(object):
    """
    CarriersConcentrationProvider2D(data)
    
    Provider of the carriers concentration in Cartesian2D geometry [1/cm³].
    
    This class is used for carriers concentration provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outCarriersConcentration(type='', mesh, interpolation='default')
    
       :param str type: Detailed information which carriers are returned. It can be
                     'majority' to return majority carriers in given material,
                     'pairs' for the concentration of electron-hole pairs,
                     'electrons', or 'holes' for particular carriers type.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the carriers concentration on the specified mesh **[1/cm³]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inCarriersConcentration = solver.outCarriersConcentration
    
       Obtain the provided field:
    
       >>> solver.outCarriersConcentration(0, mesh)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outCarriersConcentration)
       3
    
    See also:
       Receiver of carriers concentration: :class:`plask.flow.CarriersConcentrationReceiver2D`
       Data filter for carriers concentration: :class:`plask.flow.CarriersConcentrationFilter2D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, type, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param str type: Detailed information which carriers are returned. It can be
                             'majority' to return majority carriers in given material,
                             'pairs' for the concentration of electron-hole pairs,
                             'electrons', or 'holes' for particular carriers type.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class CarriersConcentrationProvider3D(object):
    """
    CarriersConcentrationProvider3D(data)
    
    Provider of the carriers concentration in Cartesian3D geometry [1/cm³].
    
    This class is used for carriers concentration provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outCarriersConcentration(type='', mesh, interpolation='default')
    
       :param str type: Detailed information which carriers are returned. It can be
                     'majority' to return majority carriers in given material,
                     'pairs' for the concentration of electron-hole pairs,
                     'electrons', or 'holes' for particular carriers type.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the carriers concentration on the specified mesh **[1/cm³]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inCarriersConcentration = solver.outCarriersConcentration
    
       Obtain the provided field:
    
       >>> solver.outCarriersConcentration(0, mesh)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outCarriersConcentration)
       3
    
    See also:
       Receiver of carriers concentration: :class:`plask.flow.CarriersConcentrationReceiver3D`
       Data filter for carriers concentration: :class:`plask.flow.CarriersConcentrationFilter3D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, type, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param str type: Detailed information which carriers are returned. It can be
                             'majority' to return majority carriers in given material,
                             'pairs' for the concentration of electron-hole pairs,
                             'electrons', or 'holes' for particular carriers type.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class CarriersConcentrationProviderCyl(object):
    """
    CarriersConcentrationProviderCyl(data)
    
    Provider of the carriers concentration in Cylindrical2D geometry [1/cm³].
    
    This class is used for carriers concentration provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outCarriersConcentration(type='', mesh, interpolation='default')
    
       :param str type: Detailed information which carriers are returned. It can be
                     'majority' to return majority carriers in given material,
                     'pairs' for the concentration of electron-hole pairs,
                     'electrons', or 'holes' for particular carriers type.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the carriers concentration on the specified mesh **[1/cm³]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inCarriersConcentration = solver.outCarriersConcentration
    
       Obtain the provided field:
    
       >>> solver.outCarriersConcentration(0, mesh)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outCarriersConcentration)
       3
    
    See also:
       Receiver of carriers concentration: :class:`plask.flow.CarriersConcentrationReceiverCyl`
       Data filter for carriers concentration: :class:`plask.flow.CarriersConcentrationFilterCyl`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, type, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param str type: Detailed information which carriers are returned. It can be
                             'majority' to return majority carriers in given material,
                             'pairs' for the concentration of electron-hole pairs,
                             'electrons', or 'holes' for particular carriers type.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class CarriersConcentrationReceiver2D(object):
    """
    CarriersConcentrationReceiver2D()
    
    Receiver of the carriers concentration in Cartesian2D geometry [1/cm³].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.CarriersConcentrationProvider2D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inCarriersConcentration = other_solver.outCarriersConcentration
    
    See also:
       Provider of carriers concentration: :class:`plask.flow.CarriersConcentrationProvider2D`
    
       Data filter for carriers concentration: :class:`plask.flow.CarriersConcentrationFilter2D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, type, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inCarriersConcentration.attach(300.)
               >>> solver.inCarriersConcentration(any_mesh)[0]
               300.
               >>> solver.inCarriersConcentration(any_mesh)[-1]
               300.
            
               >>> solver.inCarriersConcentration.attach(other_solver.outCarriersConcentration)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inCarriersConcentration = other_solver.outCarriersConcentration
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class CarriersConcentrationReceiver3D(object):
    """
    CarriersConcentrationReceiver3D()
    
    Receiver of the carriers concentration in Cartesian3D geometry [1/cm³].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.CarriersConcentrationProvider3D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inCarriersConcentration = other_solver.outCarriersConcentration
    
    See also:
       Provider of carriers concentration: :class:`plask.flow.CarriersConcentrationProvider3D`
    
       Data filter for carriers concentration: :class:`plask.flow.CarriersConcentrationFilter3D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, type, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inCarriersConcentration.attach(300.)
               >>> solver.inCarriersConcentration(any_mesh)[0]
               300.
               >>> solver.inCarriersConcentration(any_mesh)[-1]
               300.
            
               >>> solver.inCarriersConcentration.attach(other_solver.outCarriersConcentration)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inCarriersConcentration = other_solver.outCarriersConcentration
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class CarriersConcentrationReceiverCyl(object):
    """
    CarriersConcentrationReceiverCyl()
    
    Receiver of the carriers concentration in Cylindrical2D geometry [1/cm³].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.CarriersConcentrationProviderCyl`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inCarriersConcentration = other_solver.outCarriersConcentration
    
    See also:
       Provider of carriers concentration: :class:`plask.flow.CarriersConcentrationProviderCyl`
    
       Data filter for carriers concentration: :class:`plask.flow.CarriersConcentrationFilterCyl`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, type, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inCarriersConcentration.attach(300.)
               >>> solver.inCarriersConcentration(any_mesh)[0]
               300.
               >>> solver.inCarriersConcentration(any_mesh)[-1]
               300.
            
               >>> solver.inCarriersConcentration.attach(other_solver.outCarriersConcentration)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inCarriersConcentration = other_solver.outCarriersConcentration
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class ConductivityFilter2D(plask.Solver):
    """
    ConductivityFilter2D(geometry)
    
    Data filter for electrical conductivity into Cartesian2D geometry.
    
    Args:
        geometry (geometry.Cartesian2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inConductivity = my_filter.out
    """



class ConductivityFilter3D(plask.Solver):
    """
    ConductivityFilter3D(geometry)
    
    Data filter for electrical conductivity into Cartesian3D geometry.
    
    Args:
        geometry (geometry.Cartesian3D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inConductivity = my_filter.out
    """



class ConductivityFilterCyl(plask.Solver):
    """
    ConductivityFilterCyl(geometry)
    
    Data filter for electrical conductivity into Cylindrical2D geometry.
    
    Args:
        geometry (geometry.Cylindrical2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inConductivity = my_filter.out
    """



class ConductivityProvider2D(object):
    """
    ConductivityProvider2D(data)
    
    Provider of the electrical conductivity in Cartesian2D geometry [S/m].
    
    This class is used for electrical conductivity provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outConductivity(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the electrical conductivity on the specified mesh **[S/m]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inConductivity = solver.outConductivity
    
       Obtain the provided field:
    
       >>> solver.outConductivity(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of electrical conductivity: :class:`plask.flow.ConductivityReceiver2D`
       Data filter for electrical conductivity: :class:`plask.flow.ConductivityFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class ConductivityProvider3D(object):
    """
    ConductivityProvider3D(data)
    
    Provider of the electrical conductivity in Cartesian3D geometry [S/m].
    
    This class is used for electrical conductivity provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outConductivity(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the electrical conductivity on the specified mesh **[S/m]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inConductivity = solver.outConductivity
    
       Obtain the provided field:
    
       >>> solver.outConductivity(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of electrical conductivity: :class:`plask.flow.ConductivityReceiver3D`
       Data filter for electrical conductivity: :class:`plask.flow.ConductivityFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class ConductivityProviderCyl(object):
    """
    ConductivityProviderCyl(data)
    
    Provider of the electrical conductivity in Cylindrical2D geometry [S/m].
    
    This class is used for electrical conductivity provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outConductivity(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the electrical conductivity on the specified mesh **[S/m]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inConductivity = solver.outConductivity
    
       Obtain the provided field:
    
       >>> solver.outConductivity(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of electrical conductivity: :class:`plask.flow.ConductivityReceiverCyl`
       Data filter for electrical conductivity: :class:`plask.flow.ConductivityFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class ConductivityReceiver2D(object):
    """
    ConductivityReceiver2D()
    
    Receiver of the electrical conductivity in Cartesian2D geometry [S/m].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.ConductivityProvider2D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inConductivity = other_solver.outConductivity
    
    See also:
       Provider of electrical conductivity: :class:`plask.flow.ConductivityProvider2D`
    
       Data filter for electrical conductivity: :class:`plask.flow.ConductivityFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inConductivity.attach(300.)
               >>> solver.inConductivity(any_mesh)[0]
               300.
               >>> solver.inConductivity(any_mesh)[-1]
               300.
            
               >>> solver.inConductivity.attach(other_solver.outConductivity)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inConductivity = other_solver.outConductivity
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class ConductivityReceiver3D(object):
    """
    ConductivityReceiver3D()
    
    Receiver of the electrical conductivity in Cartesian3D geometry [S/m].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.ConductivityProvider3D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inConductivity = other_solver.outConductivity
    
    See also:
       Provider of electrical conductivity: :class:`plask.flow.ConductivityProvider3D`
    
       Data filter for electrical conductivity: :class:`plask.flow.ConductivityFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inConductivity.attach(300.)
               >>> solver.inConductivity(any_mesh)[0]
               300.
               >>> solver.inConductivity(any_mesh)[-1]
               300.
            
               >>> solver.inConductivity.attach(other_solver.outConductivity)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inConductivity = other_solver.outConductivity
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class ConductivityReceiverCyl(object):
    """
    ConductivityReceiverCyl()
    
    Receiver of the electrical conductivity in Cylindrical2D geometry [S/m].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.ConductivityProviderCyl`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inConductivity = other_solver.outConductivity
    
    See also:
       Provider of electrical conductivity: :class:`plask.flow.ConductivityProviderCyl`
    
       Data filter for electrical conductivity: :class:`plask.flow.ConductivityFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inConductivity.attach(300.)
               >>> solver.inConductivity(any_mesh)[0]
               300.
               >>> solver.inConductivity(any_mesh)[-1]
               300.
            
               >>> solver.inConductivity.attach(other_solver.outConductivity)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inConductivity = other_solver.outConductivity
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class CurrentDensityFilter2D(plask.Solver):
    """
    CurrentDensityFilter2D(geometry)
    
    Data filter for current density into Cartesian2D geometry.
    
    Args:
        geometry (geometry.Cartesian2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inCurrentDensity = my_filter.out
    """



class CurrentDensityFilter3D(plask.Solver):
    """
    CurrentDensityFilter3D(geometry)
    
    Data filter for current density into Cartesian3D geometry.
    
    Args:
        geometry (geometry.Cartesian3D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inCurrentDensity = my_filter.out
    """



class CurrentDensityFilterCyl(plask.Solver):
    """
    CurrentDensityFilterCyl(geometry)
    
    Data filter for current density into Cylindrical2D geometry.
    
    Args:
        geometry (geometry.Cylindrical2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inCurrentDensity = my_filter.out
    """



class CurrentDensityProvider2D(object):
    """
    CurrentDensityProvider2D(data)
    
    Provider of the current density in Cartesian2D geometry [kA/cm²].
    
    This class is used for current density provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outCurrentDensity(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the current density on the specified mesh **[kA/cm²]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inCurrentDensity = solver.outCurrentDensity
    
       Obtain the provided field:
    
       >>> solver.outCurrentDensity(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of current density: :class:`plask.flow.CurrentDensityReceiver2D`
       Data filter for current density: :class:`plask.flow.CurrentDensityFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class CurrentDensityProvider3D(object):
    """
    CurrentDensityProvider3D(data)
    
    Provider of the current density in Cartesian3D geometry [kA/cm²].
    
    This class is used for current density provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outCurrentDensity(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the current density on the specified mesh **[kA/cm²]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inCurrentDensity = solver.outCurrentDensity
    
       Obtain the provided field:
    
       >>> solver.outCurrentDensity(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of current density: :class:`plask.flow.CurrentDensityReceiver3D`
       Data filter for current density: :class:`plask.flow.CurrentDensityFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class CurrentDensityProviderCyl(object):
    """
    CurrentDensityProviderCyl(data)
    
    Provider of the current density in Cylindrical2D geometry [kA/cm²].
    
    This class is used for current density provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outCurrentDensity(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the current density on the specified mesh **[kA/cm²]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inCurrentDensity = solver.outCurrentDensity
    
       Obtain the provided field:
    
       >>> solver.outCurrentDensity(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of current density: :class:`plask.flow.CurrentDensityReceiverCyl`
       Data filter for current density: :class:`plask.flow.CurrentDensityFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class CurrentDensityReceiver2D(object):
    """
    CurrentDensityReceiver2D()
    
    Receiver of the current density in Cartesian2D geometry [kA/cm²].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.CurrentDensityProvider2D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inCurrentDensity = other_solver.outCurrentDensity
    
    See also:
       Provider of current density: :class:`plask.flow.CurrentDensityProvider2D`
    
       Data filter for current density: :class:`plask.flow.CurrentDensityFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inCurrentDensity.attach(300.)
               >>> solver.inCurrentDensity(any_mesh)[0]
               300.
               >>> solver.inCurrentDensity(any_mesh)[-1]
               300.
            
               >>> solver.inCurrentDensity.attach(other_solver.outCurrentDensity)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inCurrentDensity = other_solver.outCurrentDensity
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class CurrentDensityReceiver3D(object):
    """
    CurrentDensityReceiver3D()
    
    Receiver of the current density in Cartesian3D geometry [kA/cm²].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.CurrentDensityProvider3D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inCurrentDensity = other_solver.outCurrentDensity
    
    See also:
       Provider of current density: :class:`plask.flow.CurrentDensityProvider3D`
    
       Data filter for current density: :class:`plask.flow.CurrentDensityFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inCurrentDensity.attach(300.)
               >>> solver.inCurrentDensity(any_mesh)[0]
               300.
               >>> solver.inCurrentDensity(any_mesh)[-1]
               300.
            
               >>> solver.inCurrentDensity.attach(other_solver.outCurrentDensity)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inCurrentDensity = other_solver.outCurrentDensity
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class CurrentDensityReceiverCyl(object):
    """
    CurrentDensityReceiverCyl()
    
    Receiver of the current density in Cylindrical2D geometry [kA/cm²].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.CurrentDensityProviderCyl`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inCurrentDensity = other_solver.outCurrentDensity
    
    See also:
       Provider of current density: :class:`plask.flow.CurrentDensityProviderCyl`
    
       Data filter for current density: :class:`plask.flow.CurrentDensityFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inCurrentDensity.attach(300.)
               >>> solver.inCurrentDensity(any_mesh)[0]
               300.
               >>> solver.inCurrentDensity(any_mesh)[-1]
               300.
            
               >>> solver.inCurrentDensity.attach(other_solver.outCurrentDensity)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inCurrentDensity = other_solver.outCurrentDensity
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class EnergyLevelsProvider2D(object):
    """
    EnergyLevelsProvider2D(data)
    
    Provider of the energy levels for electrons and holes in Cartesian2D geometry [eV].
    
    This class is used for energy levels for electrons and holes provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outEnergyLevels(n=0, mesh, interpolation='default')
    
       :param int n: Value number.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the energy levels for electrons and holes on the specified mesh **[eV]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inEnergyLevels = solver.outEnergyLevels
    
       Obtain the provided field:
    
       >>> solver.outEnergyLevels(0, mesh)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outEnergyLevels)
       3
    
    See also:
       Receiver of energy levels for electrons and holes: :class:`plask.flow.EnergyLevelsReceiver2D`
       Data filter for energy levels for electrons and holes: :class:`plask.flow.EnergyLevelsFilter2D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param int n: Value number.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class EnergyLevelsProvider3D(object):
    """
    EnergyLevelsProvider3D(data)
    
    Provider of the energy levels for electrons and holes in Cartesian3D geometry [eV].
    
    This class is used for energy levels for electrons and holes provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outEnergyLevels(n=0, mesh, interpolation='default')
    
       :param int n: Value number.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the energy levels for electrons and holes on the specified mesh **[eV]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inEnergyLevels = solver.outEnergyLevels
    
       Obtain the provided field:
    
       >>> solver.outEnergyLevels(0, mesh)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outEnergyLevels)
       3
    
    See also:
       Receiver of energy levels for electrons and holes: :class:`plask.flow.EnergyLevelsReceiver3D`
       Data filter for energy levels for electrons and holes: :class:`plask.flow.EnergyLevelsFilter3D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param int n: Value number.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class EnergyLevelsProviderCyl(object):
    """
    EnergyLevelsProviderCyl(data)
    
    Provider of the energy levels for electrons and holes in Cylindrical2D geometry [eV].
    
    This class is used for energy levels for electrons and holes provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outEnergyLevels(n=0, mesh, interpolation='default')
    
       :param int n: Value number.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the energy levels for electrons and holes on the specified mesh **[eV]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inEnergyLevels = solver.outEnergyLevels
    
       Obtain the provided field:
    
       >>> solver.outEnergyLevels(0, mesh)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outEnergyLevels)
       3
    
    See also:
       Receiver of energy levels for electrons and holes: :class:`plask.flow.EnergyLevelsReceiverCyl`
       Data filter for energy levels for electrons and holes: :class:`plask.flow.EnergyLevelsFilterCyl`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param int n: Value number.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class EnergyLevelsReceiver2D(object):
    """
    EnergyLevelsReceiver2D()
    
    Receiver of the energy levels for electrons and holes in Cartesian2D geometry [eV].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.EnergyLevelsProvider2D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inEnergyLevels = other_solver.outEnergyLevels
    
    See also:
       Provider of energy levels for electrons and holes: :class:`plask.flow.EnergyLevelsProvider2D`
    
       Data filter for energy levels for electrons and holes: :class:`plask.flow.EnergyLevelsFilter2D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inEnergyLevels.attach(300.)
               >>> solver.inEnergyLevels(any_mesh)[0]
               300.
               >>> solver.inEnergyLevels(any_mesh)[-1]
               300.
            
               >>> solver.inEnergyLevels.attach(other_solver.outEnergyLevels)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inEnergyLevels = other_solver.outEnergyLevels
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class EnergyLevelsReceiver3D(object):
    """
    EnergyLevelsReceiver3D()
    
    Receiver of the energy levels for electrons and holes in Cartesian3D geometry [eV].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.EnergyLevelsProvider3D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inEnergyLevels = other_solver.outEnergyLevels
    
    See also:
       Provider of energy levels for electrons and holes: :class:`plask.flow.EnergyLevelsProvider3D`
    
       Data filter for energy levels for electrons and holes: :class:`plask.flow.EnergyLevelsFilter3D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inEnergyLevels.attach(300.)
               >>> solver.inEnergyLevels(any_mesh)[0]
               300.
               >>> solver.inEnergyLevels(any_mesh)[-1]
               300.
            
               >>> solver.inEnergyLevels.attach(other_solver.outEnergyLevels)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inEnergyLevels = other_solver.outEnergyLevels
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class EnergyLevelsReceiverCyl(object):
    """
    EnergyLevelsReceiverCyl()
    
    Receiver of the energy levels for electrons and holes in Cylindrical2D geometry [eV].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.EnergyLevelsProviderCyl`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inEnergyLevels = other_solver.outEnergyLevels
    
    See also:
       Provider of energy levels for electrons and holes: :class:`plask.flow.EnergyLevelsProviderCyl`
    
       Data filter for energy levels for electrons and holes: :class:`plask.flow.EnergyLevelsFilterCyl`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inEnergyLevels.attach(300.)
               >>> solver.inEnergyLevels(any_mesh)[0]
               300.
               >>> solver.inEnergyLevels(any_mesh)[-1]
               300.
            
               >>> solver.inEnergyLevels.attach(other_solver.outEnergyLevels)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inEnergyLevels = other_solver.outEnergyLevels
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class FermiLevelsFilter2D(plask.Solver):
    """
    FermiLevelsFilter2D(geometry)
    
    Data filter for quasi-Fermi levels for electrons and holes into Cartesian2D geometry.
    
    Args:
        geometry (geometry.Cartesian2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inFermiLevels = my_filter.out
    """



class FermiLevelsFilter3D(plask.Solver):
    """
    FermiLevelsFilter3D(geometry)
    
    Data filter for quasi-Fermi levels for electrons and holes into Cartesian3D geometry.
    
    Args:
        geometry (geometry.Cartesian3D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inFermiLevels = my_filter.out
    """



class FermiLevelsFilterCyl(plask.Solver):
    """
    FermiLevelsFilterCyl(geometry)
    
    Data filter for quasi-Fermi levels for electrons and holes into Cylindrical2D geometry.
    
    Args:
        geometry (geometry.Cylindrical2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inFermiLevels = my_filter.out
    """



class FermiLevelsProvider2D(object):
    """
    FermiLevelsProvider2D(data)
    
    Provider of the quasi-Fermi levels for electrons and holes in Cartesian2D geometry [eV].
    
    This class is used for quasi-Fermi levels for electrons and holes provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outFermiLevels(n=0, mesh, interpolation='default')
    
       :param int n: Value number.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the quasi-Fermi levels for electrons and holes on the specified mesh **[eV]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inFermiLevels = solver.outFermiLevels
    
       Obtain the provided field:
    
       >>> solver.outFermiLevels(0, mesh)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outFermiLevels)
       3
    
    See also:
       Receiver of quasi-Fermi levels for electrons and holes: :class:`plask.flow.FermiLevelsReceiver2D`
       Data filter for quasi-Fermi levels for electrons and holes: :class:`plask.flow.FermiLevelsFilter2D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param int n: Value number.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class FermiLevelsProvider3D(object):
    """
    FermiLevelsProvider3D(data)
    
    Provider of the quasi-Fermi levels for electrons and holes in Cartesian3D geometry [eV].
    
    This class is used for quasi-Fermi levels for electrons and holes provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outFermiLevels(n=0, mesh, interpolation='default')
    
       :param int n: Value number.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the quasi-Fermi levels for electrons and holes on the specified mesh **[eV]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inFermiLevels = solver.outFermiLevels
    
       Obtain the provided field:
    
       >>> solver.outFermiLevels(0, mesh)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outFermiLevels)
       3
    
    See also:
       Receiver of quasi-Fermi levels for electrons and holes: :class:`plask.flow.FermiLevelsReceiver3D`
       Data filter for quasi-Fermi levels for electrons and holes: :class:`plask.flow.FermiLevelsFilter3D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param int n: Value number.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class FermiLevelsProviderCyl(object):
    """
    FermiLevelsProviderCyl(data)
    
    Provider of the quasi-Fermi levels for electrons and holes in Cylindrical2D geometry [eV].
    
    This class is used for quasi-Fermi levels for electrons and holes provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outFermiLevels(n=0, mesh, interpolation='default')
    
       :param int n: Value number.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the quasi-Fermi levels for electrons and holes on the specified mesh **[eV]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inFermiLevels = solver.outFermiLevels
    
       Obtain the provided field:
    
       >>> solver.outFermiLevels(0, mesh)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outFermiLevels)
       3
    
    See also:
       Receiver of quasi-Fermi levels for electrons and holes: :class:`plask.flow.FermiLevelsReceiverCyl`
       Data filter for quasi-Fermi levels for electrons and holes: :class:`plask.flow.FermiLevelsFilterCyl`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param int n: Value number.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class FermiLevelsReceiver2D(object):
    """
    FermiLevelsReceiver2D()
    
    Receiver of the quasi-Fermi levels for electrons and holes in Cartesian2D geometry [eV].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.FermiLevelsProvider2D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inFermiLevels = other_solver.outFermiLevels
    
    See also:
       Provider of quasi-Fermi levels for electrons and holes: :class:`plask.flow.FermiLevelsProvider2D`
    
       Data filter for quasi-Fermi levels for electrons and holes: :class:`plask.flow.FermiLevelsFilter2D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inFermiLevels.attach(300.)
               >>> solver.inFermiLevels(any_mesh)[0]
               300.
               >>> solver.inFermiLevels(any_mesh)[-1]
               300.
            
               >>> solver.inFermiLevels.attach(other_solver.outFermiLevels)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inFermiLevels = other_solver.outFermiLevels
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class FermiLevelsReceiver3D(object):
    """
    FermiLevelsReceiver3D()
    
    Receiver of the quasi-Fermi levels for electrons and holes in Cartesian3D geometry [eV].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.FermiLevelsProvider3D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inFermiLevels = other_solver.outFermiLevels
    
    See also:
       Provider of quasi-Fermi levels for electrons and holes: :class:`plask.flow.FermiLevelsProvider3D`
    
       Data filter for quasi-Fermi levels for electrons and holes: :class:`plask.flow.FermiLevelsFilter3D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inFermiLevels.attach(300.)
               >>> solver.inFermiLevels(any_mesh)[0]
               300.
               >>> solver.inFermiLevels(any_mesh)[-1]
               300.
            
               >>> solver.inFermiLevels.attach(other_solver.outFermiLevels)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inFermiLevels = other_solver.outFermiLevels
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class FermiLevelsReceiverCyl(object):
    """
    FermiLevelsReceiverCyl()
    
    Receiver of the quasi-Fermi levels for electrons and holes in Cylindrical2D geometry [eV].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.FermiLevelsProviderCyl`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inFermiLevels = other_solver.outFermiLevels
    
    See also:
       Provider of quasi-Fermi levels for electrons and holes: :class:`plask.flow.FermiLevelsProviderCyl`
    
       Data filter for quasi-Fermi levels for electrons and holes: :class:`plask.flow.FermiLevelsFilterCyl`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inFermiLevels.attach(300.)
               >>> solver.inFermiLevels(any_mesh)[0]
               300.
               >>> solver.inFermiLevels(any_mesh)[-1]
               300.
            
               >>> solver.inFermiLevels.attach(other_solver.outFermiLevels)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inFermiLevels = other_solver.outFermiLevels
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class GainFilter2D(plask.Solver):
    """
    GainFilter2D(geometry)
    
    Data filter for material gain into Cartesian2D geometry.
    
    Args:
        geometry (geometry.Cartesian2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inGain = my_filter.out
    """



class GainFilter3D(plask.Solver):
    """
    GainFilter3D(geometry)
    
    Data filter for material gain into Cartesian3D geometry.
    
    Args:
        geometry (geometry.Cartesian3D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inGain = my_filter.out
    """



class GainFilterCyl(plask.Solver):
    """
    GainFilterCyl(geometry)
    
    Data filter for material gain into Cylindrical2D geometry.
    
    Args:
        geometry (geometry.Cylindrical2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inGain = my_filter.out
    """



class GainProvider2D(object):
    """
    GainProvider2D(data)
    
    Provider of the material gain in Cartesian2D geometry [1/cm].
    
    This class is used for material gain provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outGain(deriv='', mesh, wavelength, interpolation='default')
    
       :param str deriv: Gain derivative to return. can be '' (empty) or 'conc'.
                      In the latter case, the gain derivative over carriers
                      concentration is returned.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       :param float wavelength: The wavelength at which the gain is computed [nm].
    
       :return: Data with the material gain on the specified mesh **[1/cm]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inGain = solver.outGain
    
       Obtain the provided field:
    
       >>> solver.outGain(0, mesh, wavelength)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outGain)
       3
    
    See also:
       Receiver of material gain: :class:`plask.flow.GainReceiver2D`
       Data filter for material gain: :class:`plask.flow.GainFilter2D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, wavelength, interpolation='DEFAULT')
        __call__(self, deriv, mesh, wavelength, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param str deriv: Gain derivative to return. can be '' (empty) or 'conc'.
                              In the latter case, the gain derivative over carriers
                              concentration is returned.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
            :param float wavelength: The wavelength at which the gain is computed [nm].
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class GainProvider3D(object):
    """
    GainProvider3D(data)
    
    Provider of the material gain in Cartesian3D geometry [1/cm].
    
    This class is used for material gain provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outGain(deriv='', mesh, wavelength, interpolation='default')
    
       :param str deriv: Gain derivative to return. can be '' (empty) or 'conc'.
                      In the latter case, the gain derivative over carriers
                      concentration is returned.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       :param float wavelength: The wavelength at which the gain is computed [nm].
    
       :return: Data with the material gain on the specified mesh **[1/cm]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inGain = solver.outGain
    
       Obtain the provided field:
    
       >>> solver.outGain(0, mesh, wavelength)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outGain)
       3
    
    See also:
       Receiver of material gain: :class:`plask.flow.GainReceiver3D`
       Data filter for material gain: :class:`plask.flow.GainFilter3D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, wavelength, interpolation='DEFAULT')
        __call__(self, deriv, mesh, wavelength, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param str deriv: Gain derivative to return. can be '' (empty) or 'conc'.
                              In the latter case, the gain derivative over carriers
                              concentration is returned.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
            :param float wavelength: The wavelength at which the gain is computed [nm].
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class GainProviderCyl(object):
    """
    GainProviderCyl(data)
    
    Provider of the material gain in Cylindrical2D geometry [1/cm].
    
    This class is used for material gain provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outGain(deriv='', mesh, wavelength, interpolation='default')
    
       :param str deriv: Gain derivative to return. can be '' (empty) or 'conc'.
                      In the latter case, the gain derivative over carriers
                      concentration is returned.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       :param float wavelength: The wavelength at which the gain is computed [nm].
    
       :return: Data with the material gain on the specified mesh **[1/cm]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inGain = solver.outGain
    
       Obtain the provided field:
    
       >>> solver.outGain(0, mesh, wavelength)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outGain)
       3
    
    See also:
       Receiver of material gain: :class:`plask.flow.GainReceiverCyl`
       Data filter for material gain: :class:`plask.flow.GainFilterCyl`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, wavelength, interpolation='DEFAULT')
        __call__(self, deriv, mesh, wavelength, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param str deriv: Gain derivative to return. can be '' (empty) or 'conc'.
                              In the latter case, the gain derivative over carriers
                              concentration is returned.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
            :param float wavelength: The wavelength at which the gain is computed [nm].
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class GainReceiver2D(object):
    """
    GainReceiver2D()
    
    Receiver of the material gain in Cartesian2D geometry [1/cm].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.GainProvider2D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inGain = other_solver.outGain
    
    See also:
       Provider of material gain: :class:`plask.flow.GainProvider2D`
    
       Data filter for material gain: :class:`plask.flow.GainFilter2D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, wavelength, interpolation='DEFAULT')
        __call__(self, deriv, mesh, wavelength, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inGain.attach(300.)
               >>> solver.inGain(any_mesh)[0]
               300.
               >>> solver.inGain(any_mesh)[-1]
               300.
            
               >>> solver.inGain.attach(other_solver.outGain)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inGain = other_solver.outGain
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class GainReceiver3D(object):
    """
    GainReceiver3D()
    
    Receiver of the material gain in Cartesian3D geometry [1/cm].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.GainProvider3D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inGain = other_solver.outGain
    
    See also:
       Provider of material gain: :class:`plask.flow.GainProvider3D`
    
       Data filter for material gain: :class:`plask.flow.GainFilter3D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, wavelength, interpolation='DEFAULT')
        __call__(self, deriv, mesh, wavelength, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inGain.attach(300.)
               >>> solver.inGain(any_mesh)[0]
               300.
               >>> solver.inGain(any_mesh)[-1]
               300.
            
               >>> solver.inGain.attach(other_solver.outGain)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inGain = other_solver.outGain
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class GainReceiverCyl(object):
    """
    GainReceiverCyl()
    
    Receiver of the material gain in Cylindrical2D geometry [1/cm].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.GainProviderCyl`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inGain = other_solver.outGain
    
    See also:
       Provider of material gain: :class:`plask.flow.GainProviderCyl`
    
       Data filter for material gain: :class:`plask.flow.GainFilterCyl`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, wavelength, interpolation='DEFAULT')
        __call__(self, deriv, mesh, wavelength, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inGain.attach(300.)
               >>> solver.inGain(any_mesh)[0]
               300.
               >>> solver.inGain(any_mesh)[-1]
               300.
            
               >>> solver.inGain.attach(other_solver.outGain)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inGain = other_solver.outGain
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class HeatFilter2D(plask.Solver):
    """
    HeatFilter2D(geometry)
    
    Data filter for heat sources density into Cartesian2D geometry.
    
    Args:
        geometry (geometry.Cartesian2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inHeat = my_filter.out
    """



class HeatFilter3D(plask.Solver):
    """
    HeatFilter3D(geometry)
    
    Data filter for heat sources density into Cartesian3D geometry.
    
    Args:
        geometry (geometry.Cartesian3D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inHeat = my_filter.out
    """



class HeatFilterCyl(plask.Solver):
    """
    HeatFilterCyl(geometry)
    
    Data filter for heat sources density into Cylindrical2D geometry.
    
    Args:
        geometry (geometry.Cylindrical2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inHeat = my_filter.out
    """



class HeatFluxFilter2D(plask.Solver):
    """
    HeatFluxFilter2D(geometry)
    
    Data filter for heat flux into Cartesian2D geometry.
    
    Args:
        geometry (geometry.Cartesian2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inHeatFlux = my_filter.out
    """



class HeatFluxFilter3D(plask.Solver):
    """
    HeatFluxFilter3D(geometry)
    
    Data filter for heat flux into Cartesian3D geometry.
    
    Args:
        geometry (geometry.Cartesian3D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inHeatFlux = my_filter.out
    """



class HeatFluxFilterCyl(plask.Solver):
    """
    HeatFluxFilterCyl(geometry)
    
    Data filter for heat flux into Cylindrical2D geometry.
    
    Args:
        geometry (geometry.Cylindrical2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inHeatFlux = my_filter.out
    """



class HeatFluxProvider2D(object):
    """
    HeatFluxProvider2D(data)
    
    Provider of the heat flux in Cartesian2D geometry [W/m²].
    
    This class is used for heat flux provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outHeatFlux(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the heat flux on the specified mesh **[W/m²]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inHeatFlux = solver.outHeatFlux
    
       Obtain the provided field:
    
       >>> solver.outHeatFlux(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of heat flux: :class:`plask.flow.HeatFluxReceiver2D`
       Data filter for heat flux: :class:`plask.flow.HeatFluxFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class HeatFluxProvider3D(object):
    """
    HeatFluxProvider3D(data)
    
    Provider of the heat flux in Cartesian3D geometry [W/m²].
    
    This class is used for heat flux provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outHeatFlux(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the heat flux on the specified mesh **[W/m²]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inHeatFlux = solver.outHeatFlux
    
       Obtain the provided field:
    
       >>> solver.outHeatFlux(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of heat flux: :class:`plask.flow.HeatFluxReceiver3D`
       Data filter for heat flux: :class:`plask.flow.HeatFluxFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class HeatFluxProviderCyl(object):
    """
    HeatFluxProviderCyl(data)
    
    Provider of the heat flux in Cylindrical2D geometry [W/m²].
    
    This class is used for heat flux provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outHeatFlux(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the heat flux on the specified mesh **[W/m²]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inHeatFlux = solver.outHeatFlux
    
       Obtain the provided field:
    
       >>> solver.outHeatFlux(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of heat flux: :class:`plask.flow.HeatFluxReceiverCyl`
       Data filter for heat flux: :class:`plask.flow.HeatFluxFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class HeatFluxReceiver2D(object):
    """
    HeatFluxReceiver2D()
    
    Receiver of the heat flux in Cartesian2D geometry [W/m²].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.HeatFluxProvider2D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inHeatFlux = other_solver.outHeatFlux
    
    See also:
       Provider of heat flux: :class:`plask.flow.HeatFluxProvider2D`
    
       Data filter for heat flux: :class:`plask.flow.HeatFluxFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inHeatFlux.attach(300.)
               >>> solver.inHeatFlux(any_mesh)[0]
               300.
               >>> solver.inHeatFlux(any_mesh)[-1]
               300.
            
               >>> solver.inHeatFlux.attach(other_solver.outHeatFlux)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inHeatFlux = other_solver.outHeatFlux
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class HeatFluxReceiver3D(object):
    """
    HeatFluxReceiver3D()
    
    Receiver of the heat flux in Cartesian3D geometry [W/m²].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.HeatFluxProvider3D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inHeatFlux = other_solver.outHeatFlux
    
    See also:
       Provider of heat flux: :class:`plask.flow.HeatFluxProvider3D`
    
       Data filter for heat flux: :class:`plask.flow.HeatFluxFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inHeatFlux.attach(300.)
               >>> solver.inHeatFlux(any_mesh)[0]
               300.
               >>> solver.inHeatFlux(any_mesh)[-1]
               300.
            
               >>> solver.inHeatFlux.attach(other_solver.outHeatFlux)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inHeatFlux = other_solver.outHeatFlux
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class HeatFluxReceiverCyl(object):
    """
    HeatFluxReceiverCyl()
    
    Receiver of the heat flux in Cylindrical2D geometry [W/m²].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.HeatFluxProviderCyl`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inHeatFlux = other_solver.outHeatFlux
    
    See also:
       Provider of heat flux: :class:`plask.flow.HeatFluxProviderCyl`
    
       Data filter for heat flux: :class:`plask.flow.HeatFluxFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inHeatFlux.attach(300.)
               >>> solver.inHeatFlux(any_mesh)[0]
               300.
               >>> solver.inHeatFlux(any_mesh)[-1]
               300.
            
               >>> solver.inHeatFlux.attach(other_solver.outHeatFlux)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inHeatFlux = other_solver.outHeatFlux
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class HeatProvider2D(object):
    """
    HeatProvider2D(data)
    
    Provider of the heat sources density in Cartesian2D geometry [W/m³].
    
    This class is used for heat sources density provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outHeat(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the heat sources density on the specified mesh **[W/m³]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inHeat = solver.outHeat
    
       Obtain the provided field:
    
       >>> solver.outHeat(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of heat sources density: :class:`plask.flow.HeatReceiver2D`
       Data filter for heat sources density: :class:`plask.flow.HeatFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class HeatProvider3D(object):
    """
    HeatProvider3D(data)
    
    Provider of the heat sources density in Cartesian3D geometry [W/m³].
    
    This class is used for heat sources density provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outHeat(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the heat sources density on the specified mesh **[W/m³]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inHeat = solver.outHeat
    
       Obtain the provided field:
    
       >>> solver.outHeat(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of heat sources density: :class:`plask.flow.HeatReceiver3D`
       Data filter for heat sources density: :class:`plask.flow.HeatFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class HeatProviderCyl(object):
    """
    HeatProviderCyl(data)
    
    Provider of the heat sources density in Cylindrical2D geometry [W/m³].
    
    This class is used for heat sources density provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outHeat(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the heat sources density on the specified mesh **[W/m³]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inHeat = solver.outHeat
    
       Obtain the provided field:
    
       >>> solver.outHeat(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of heat sources density: :class:`plask.flow.HeatReceiverCyl`
       Data filter for heat sources density: :class:`plask.flow.HeatFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class HeatReceiver2D(object):
    """
    HeatReceiver2D()
    
    Receiver of the heat sources density in Cartesian2D geometry [W/m³].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.HeatProvider2D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inHeat = other_solver.outHeat
    
    See also:
       Provider of heat sources density: :class:`plask.flow.HeatProvider2D`
    
       Data filter for heat sources density: :class:`plask.flow.HeatFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inHeat.attach(300.)
               >>> solver.inHeat(any_mesh)[0]
               300.
               >>> solver.inHeat(any_mesh)[-1]
               300.
            
               >>> solver.inHeat.attach(other_solver.outHeat)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inHeat = other_solver.outHeat
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class HeatReceiver3D(object):
    """
    HeatReceiver3D()
    
    Receiver of the heat sources density in Cartesian3D geometry [W/m³].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.HeatProvider3D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inHeat = other_solver.outHeat
    
    See also:
       Provider of heat sources density: :class:`plask.flow.HeatProvider3D`
    
       Data filter for heat sources density: :class:`plask.flow.HeatFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inHeat.attach(300.)
               >>> solver.inHeat(any_mesh)[0]
               300.
               >>> solver.inHeat(any_mesh)[-1]
               300.
            
               >>> solver.inHeat.attach(other_solver.outHeat)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inHeat = other_solver.outHeat
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class HeatReceiverCyl(object):
    """
    HeatReceiverCyl()
    
    Receiver of the heat sources density in Cylindrical2D geometry [W/m³].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.HeatProviderCyl`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inHeat = other_solver.outHeat
    
    See also:
       Provider of heat sources density: :class:`plask.flow.HeatProviderCyl`
    
       Data filter for heat sources density: :class:`plask.flow.HeatFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inHeat.attach(300.)
               >>> solver.inHeat(any_mesh)[0]
               300.
               >>> solver.inHeat(any_mesh)[-1]
               300.
            
               >>> solver.inHeat.attach(other_solver.outHeat)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inHeat = other_solver.outHeat
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class HeatSumProvider2D(HeatProvider2D):
    """
    Combined provider for heat sources density.
    
    This provider holds a sum of the other providers, so the provided field
    is the sum of its sources.
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def add(self, provider):
        """
        add(self, provider)
        
            Add another provider to the combination.
            Using this function is equal to calling ``self += provider``.
            
            Args:
                provider: Provider to add.
        """

    def clear(self):
        """
        clear(self)
        
            Clear all elements of the combined provider.
        """

    def remove(self, provider):
        """
        remove(self, provider)
        
            Remove provider from the combination.
            
            Args:
                provider: Provider to remove.
        """



class HeatSumProviderCyl(HeatProviderCyl):
    """
    Combined provider for heat sources density.
    
    This provider holds a sum of the other providers, so the provided field
    is the sum of its sources.
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def add(self, provider):
        """
        add(self, provider)
        
            Add another provider to the combination.
            Using this function is equal to calling ``self += provider``.
            
            Args:
                provider: Provider to add.
        """

    def clear(self):
        """
        clear(self)
        
            Clear all elements of the combined provider.
        """

    def remove(self, provider):
        """
        remove(self, provider)
        
            Remove provider from the combination.
            
            Args:
                provider: Provider to remove.
        """



class LightEFilter2D(plask.Solver):
    """
    LightEFilter2D(geometry)
    
    Data filter for electric field into Cartesian2D geometry.
    
    Args:
        geometry (geometry.Cartesian2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inLightE = my_filter.out
    """



class LightEFilter3D(plask.Solver):
    """
    LightEFilter3D(geometry)
    
    Data filter for electric field into Cartesian3D geometry.
    
    Args:
        geometry (geometry.Cartesian3D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inLightE = my_filter.out
    """



class LightEFilterCyl(plask.Solver):
    """
    LightEFilterCyl(geometry)
    
    Data filter for electric field into Cylindrical2D geometry.
    
    Args:
        geometry (geometry.Cylindrical2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inLightE = my_filter.out
    """



class LightEProvider2D(object):
    """
    LightEProvider2D(data)
    
    Provider of the electric field in Cartesian2D geometry [V/m].
    
    This class is used for electric field provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outLightE(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the electric field on the specified mesh **[V/m]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inLightE = solver.outLightE
    
       Obtain the provided field:
    
       >>> solver.outLightE(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of electric field: :class:`plask.flow.LightEReceiver2D`
       Data filter for electric field: :class:`plask.flow.LightEFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class LightEProvider3D(object):
    """
    LightEProvider3D(data)
    
    Provider of the electric field in Cartesian3D geometry [V/m].
    
    This class is used for electric field provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outLightE(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the electric field on the specified mesh **[V/m]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inLightE = solver.outLightE
    
       Obtain the provided field:
    
       >>> solver.outLightE(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of electric field: :class:`plask.flow.LightEReceiver3D`
       Data filter for electric field: :class:`plask.flow.LightEFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class LightEProviderCyl(object):
    """
    LightEProviderCyl(data)
    
    Provider of the electric field in Cylindrical2D geometry [V/m].
    
    This class is used for electric field provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outLightE(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the electric field on the specified mesh **[V/m]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inLightE = solver.outLightE
    
       Obtain the provided field:
    
       >>> solver.outLightE(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of electric field: :class:`plask.flow.LightEReceiverCyl`
       Data filter for electric field: :class:`plask.flow.LightEFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class LightEReceiver2D(object):
    """
    LightEReceiver2D()
    
    Receiver of the electric field in Cartesian2D geometry [V/m].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.LightEProvider2D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inLightE = other_solver.outLightE
    
    See also:
       Provider of electric field: :class:`plask.flow.LightEProvider2D`
    
       Data filter for electric field: :class:`plask.flow.LightEFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inLightE.attach(300.)
               >>> solver.inLightE(any_mesh)[0]
               300.
               >>> solver.inLightE(any_mesh)[-1]
               300.
            
               >>> solver.inLightE.attach(other_solver.outLightE)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inLightE = other_solver.outLightE
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class LightEReceiver3D(object):
    """
    LightEReceiver3D()
    
    Receiver of the electric field in Cartesian3D geometry [V/m].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.LightEProvider3D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inLightE = other_solver.outLightE
    
    See also:
       Provider of electric field: :class:`plask.flow.LightEProvider3D`
    
       Data filter for electric field: :class:`plask.flow.LightEFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inLightE.attach(300.)
               >>> solver.inLightE(any_mesh)[0]
               300.
               >>> solver.inLightE(any_mesh)[-1]
               300.
            
               >>> solver.inLightE.attach(other_solver.outLightE)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inLightE = other_solver.outLightE
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class LightEReceiverCyl(object):
    """
    LightEReceiverCyl()
    
    Receiver of the electric field in Cylindrical2D geometry [V/m].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.LightEProviderCyl`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inLightE = other_solver.outLightE
    
    See also:
       Provider of electric field: :class:`plask.flow.LightEProviderCyl`
    
       Data filter for electric field: :class:`plask.flow.LightEFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inLightE.attach(300.)
               >>> solver.inLightE(any_mesh)[0]
               300.
               >>> solver.inLightE(any_mesh)[-1]
               300.
            
               >>> solver.inLightE.attach(other_solver.outLightE)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inLightE = other_solver.outLightE
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class LightHFilter2D(plask.Solver):
    """
    LightHFilter2D(geometry)
    
    Data filter for magnetic field into Cartesian2D geometry.
    
    Args:
        geometry (geometry.Cartesian2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inLightH = my_filter.out
    """



class LightHFilter3D(plask.Solver):
    """
    LightHFilter3D(geometry)
    
    Data filter for magnetic field into Cartesian3D geometry.
    
    Args:
        geometry (geometry.Cartesian3D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inLightH = my_filter.out
    """



class LightHFilterCyl(plask.Solver):
    """
    LightHFilterCyl(geometry)
    
    Data filter for magnetic field into Cylindrical2D geometry.
    
    Args:
        geometry (geometry.Cylindrical2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inLightH = my_filter.out
    """



class LightHProvider2D(object):
    """
    LightHProvider2D(data)
    
    Provider of the magnetic field in Cartesian2D geometry [A/m].
    
    This class is used for magnetic field provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outLightH(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the magnetic field on the specified mesh **[A/m]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inLightH = solver.outLightH
    
       Obtain the provided field:
    
       >>> solver.outLightH(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of magnetic field: :class:`plask.flow.LightHReceiver2D`
       Data filter for magnetic field: :class:`plask.flow.LightHFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class LightHProvider3D(object):
    """
    LightHProvider3D(data)
    
    Provider of the magnetic field in Cartesian3D geometry [A/m].
    
    This class is used for magnetic field provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outLightH(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the magnetic field on the specified mesh **[A/m]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inLightH = solver.outLightH
    
       Obtain the provided field:
    
       >>> solver.outLightH(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of magnetic field: :class:`plask.flow.LightHReceiver3D`
       Data filter for magnetic field: :class:`plask.flow.LightHFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class LightHProviderCyl(object):
    """
    LightHProviderCyl(data)
    
    Provider of the magnetic field in Cylindrical2D geometry [A/m].
    
    This class is used for magnetic field provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outLightH(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the magnetic field on the specified mesh **[A/m]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inLightH = solver.outLightH
    
       Obtain the provided field:
    
       >>> solver.outLightH(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of magnetic field: :class:`plask.flow.LightHReceiverCyl`
       Data filter for magnetic field: :class:`plask.flow.LightHFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class LightHReceiver2D(object):
    """
    LightHReceiver2D()
    
    Receiver of the magnetic field in Cartesian2D geometry [A/m].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.LightHProvider2D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inLightH = other_solver.outLightH
    
    See also:
       Provider of magnetic field: :class:`plask.flow.LightHProvider2D`
    
       Data filter for magnetic field: :class:`plask.flow.LightHFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inLightH.attach(300.)
               >>> solver.inLightH(any_mesh)[0]
               300.
               >>> solver.inLightH(any_mesh)[-1]
               300.
            
               >>> solver.inLightH.attach(other_solver.outLightH)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inLightH = other_solver.outLightH
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class LightHReceiver3D(object):
    """
    LightHReceiver3D()
    
    Receiver of the magnetic field in Cartesian3D geometry [A/m].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.LightHProvider3D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inLightH = other_solver.outLightH
    
    See also:
       Provider of magnetic field: :class:`plask.flow.LightHProvider3D`
    
       Data filter for magnetic field: :class:`plask.flow.LightHFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inLightH.attach(300.)
               >>> solver.inLightH(any_mesh)[0]
               300.
               >>> solver.inLightH(any_mesh)[-1]
               300.
            
               >>> solver.inLightH.attach(other_solver.outLightH)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inLightH = other_solver.outLightH
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class LightHReceiverCyl(object):
    """
    LightHReceiverCyl()
    
    Receiver of the magnetic field in Cylindrical2D geometry [A/m].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.LightHProviderCyl`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inLightH = other_solver.outLightH
    
    See also:
       Provider of magnetic field: :class:`plask.flow.LightHProviderCyl`
    
       Data filter for magnetic field: :class:`plask.flow.LightHFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inLightH.attach(300.)
               >>> solver.inLightH(any_mesh)[0]
               300.
               >>> solver.inLightH(any_mesh)[-1]
               300.
            
               >>> solver.inLightH.attach(other_solver.outLightH)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inLightH = other_solver.outLightH
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class LightMagnitudeFilter2D(plask.Solver):
    """
    LightMagnitudeFilter2D(geometry)
    
    Data filter for optical field magnitude into Cartesian2D geometry.
    
    Args:
        geometry (geometry.Cartesian2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inLightMagnitude = my_filter.out
    """



class LightMagnitudeFilter3D(plask.Solver):
    """
    LightMagnitudeFilter3D(geometry)
    
    Data filter for optical field magnitude into Cartesian3D geometry.
    
    Args:
        geometry (geometry.Cartesian3D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inLightMagnitude = my_filter.out
    """



class LightMagnitudeFilterCyl(plask.Solver):
    """
    LightMagnitudeFilterCyl(geometry)
    
    Data filter for optical field magnitude into Cylindrical2D geometry.
    
    Args:
        geometry (geometry.Cylindrical2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inLightMagnitude = my_filter.out
    """



class LightMagnitudeProvider2D(object):
    """
    LightMagnitudeProvider2D(data)
    
    Provider of the optical field magnitude in Cartesian2D geometry [W/m²].
    
    This class is used for optical field magnitude provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outLightMagnitude(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the optical field magnitude on the specified mesh **[W/m²]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inLightMagnitude = solver.outLightMagnitude
    
       Obtain the provided field:
    
       >>> solver.outLightMagnitude(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of optical field magnitude: :class:`plask.flow.LightMagnitudeReceiver2D`
       Data filter for optical field magnitude: :class:`plask.flow.LightMagnitudeFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class LightMagnitudeProvider3D(object):
    """
    LightMagnitudeProvider3D(data)
    
    Provider of the optical field magnitude in Cartesian3D geometry [W/m²].
    
    This class is used for optical field magnitude provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outLightMagnitude(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the optical field magnitude on the specified mesh **[W/m²]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inLightMagnitude = solver.outLightMagnitude
    
       Obtain the provided field:
    
       >>> solver.outLightMagnitude(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of optical field magnitude: :class:`plask.flow.LightMagnitudeReceiver3D`
       Data filter for optical field magnitude: :class:`plask.flow.LightMagnitudeFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class LightMagnitudeProviderCyl(object):
    """
    LightMagnitudeProviderCyl(data)
    
    Provider of the optical field magnitude in Cylindrical2D geometry [W/m²].
    
    This class is used for optical field magnitude provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outLightMagnitude(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the optical field magnitude on the specified mesh **[W/m²]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inLightMagnitude = solver.outLightMagnitude
    
       Obtain the provided field:
    
       >>> solver.outLightMagnitude(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of optical field magnitude: :class:`plask.flow.LightMagnitudeReceiverCyl`
       Data filter for optical field magnitude: :class:`plask.flow.LightMagnitudeFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class LightMagnitudeReceiver2D(object):
    """
    LightMagnitudeReceiver2D()
    
    Receiver of the optical field magnitude in Cartesian2D geometry [W/m²].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.LightMagnitudeProvider2D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inLightMagnitude = other_solver.outLightMagnitude
    
    See also:
       Provider of optical field magnitude: :class:`plask.flow.LightMagnitudeProvider2D`
    
       Data filter for optical field magnitude: :class:`plask.flow.LightMagnitudeFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inLightMagnitude.attach(300.)
               >>> solver.inLightMagnitude(any_mesh)[0]
               300.
               >>> solver.inLightMagnitude(any_mesh)[-1]
               300.
            
               >>> solver.inLightMagnitude.attach(other_solver.outLightMagnitude)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inLightMagnitude = other_solver.outLightMagnitude
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class LightMagnitudeReceiver3D(object):
    """
    LightMagnitudeReceiver3D()
    
    Receiver of the optical field magnitude in Cartesian3D geometry [W/m²].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.LightMagnitudeProvider3D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inLightMagnitude = other_solver.outLightMagnitude
    
    See also:
       Provider of optical field magnitude: :class:`plask.flow.LightMagnitudeProvider3D`
    
       Data filter for optical field magnitude: :class:`plask.flow.LightMagnitudeFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inLightMagnitude.attach(300.)
               >>> solver.inLightMagnitude(any_mesh)[0]
               300.
               >>> solver.inLightMagnitude(any_mesh)[-1]
               300.
            
               >>> solver.inLightMagnitude.attach(other_solver.outLightMagnitude)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inLightMagnitude = other_solver.outLightMagnitude
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class LightMagnitudeReceiverCyl(object):
    """
    LightMagnitudeReceiverCyl()
    
    Receiver of the optical field magnitude in Cylindrical2D geometry [W/m²].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.LightMagnitudeProviderCyl`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inLightMagnitude = other_solver.outLightMagnitude
    
    See also:
       Provider of optical field magnitude: :class:`plask.flow.LightMagnitudeProviderCyl`
    
       Data filter for optical field magnitude: :class:`plask.flow.LightMagnitudeFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inLightMagnitude.attach(300.)
               >>> solver.inLightMagnitude(any_mesh)[0]
               300.
               >>> solver.inLightMagnitude(any_mesh)[-1]
               300.
            
               >>> solver.inLightMagnitude.attach(other_solver.outLightMagnitude)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inLightMagnitude = other_solver.outLightMagnitude
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class ModeEffectiveIndexProvider(object):
    """
    ModeEffectiveIndexProvider(data)
    
    Provider of the effective index [-].
    
    This class is used for effective index provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: provided value or callable returning it on request.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outModeEffectiveIndex(n=0)
    
       :param int n: Value number.
    
       
       :return: Value of the effective index **[-]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inModeEffectiveIndex = solver.outModeEffectiveIndex
    
       Obtain the provided value:
    
       >>> solver.outModeEffectiveIndex(0)
       1000
    
       Test the number of provided values:
    
       >>> len(solver.outModeEffectiveIndex)
       3
    
    See also:
       Receiver of effective index: :class:`plask.flow.ModeEffectiveIndexReceiver`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self)
        __call__(self, n)
        
            Get value from the provider.
            
            :param int n: Value number.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class ModeEffectiveIndexReceiver(object):
    """
    ModeEffectiveIndexReceiver()
    
    Receiver of the effective index [-].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.ModeEffectiveIndexProvider`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inModeEffectiveIndex = other_solver.outModeEffectiveIndex
    
    See also:
       Provider of effective index: :class:`plask.flow.ModeEffectiveIndexProvider`
    
       Data filter for effective index: :class:`plask.flow.ModeEffectiveIndexFilter`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self)
        __call__(self, n)
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inModeEffectiveIndex.attach(300.)
               >>> solver.inModeEffectiveIndex(any_mesh)[0]
               300.
               >>> solver.inModeEffectiveIndex(any_mesh)[-1]
               300.
            
               >>> solver.inModeEffectiveIndex.attach(other_solver.outModeEffectiveIndex)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inModeEffectiveIndex = other_solver.outModeEffectiveIndex
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class ModeLightEFilter2D(plask.Solver):
    """
    ModeLightEFilter2D(geometry)
    
    Data filter for electric field into Cartesian2D geometry.
    
    Args:
        geometry (geometry.Cartesian2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inModeLightE = my_filter.out
    """



class ModeLightEFilter3D(plask.Solver):
    """
    ModeLightEFilter3D(geometry)
    
    Data filter for electric field into Cartesian3D geometry.
    
    Args:
        geometry (geometry.Cartesian3D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inModeLightE = my_filter.out
    """



class ModeLightEFilterCyl(plask.Solver):
    """
    ModeLightEFilterCyl(geometry)
    
    Data filter for electric field into Cylindrical2D geometry.
    
    Args:
        geometry (geometry.Cylindrical2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inModeLightE = my_filter.out
    """



class ModeLightEProvider2D(object):
    """
    ModeLightEProvider2D(data)
    
    Provider of the electric field in Cartesian2D geometry [V/m].
    
    This class is used for electric field provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outModeLightE(n=0, mesh, interpolation='default')
    
       :param int n: Number of the mode found with :meth:`find_mode`.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the electric field on the specified mesh **[V/m]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inModeLightE = solver.outModeLightE
    
       Obtain the provided field:
    
       >>> solver.outModeLightE(0, mesh)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outModeLightE)
       3
    
    See also:
       Receiver of electric field: :class:`plask.flow.ModeLightEReceiver2D`
       Data filter for electric field: :class:`plask.flow.ModeLightEFilter2D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param int n: Number of the mode found with :meth:`find_mode`.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class ModeLightEProvider3D(object):
    """
    ModeLightEProvider3D(data)
    
    Provider of the electric field in Cartesian3D geometry [V/m].
    
    This class is used for electric field provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outModeLightE(n=0, mesh, interpolation='default')
    
       :param int n: Number of the mode found with :meth:`find_mode`.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the electric field on the specified mesh **[V/m]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inModeLightE = solver.outModeLightE
    
       Obtain the provided field:
    
       >>> solver.outModeLightE(0, mesh)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outModeLightE)
       3
    
    See also:
       Receiver of electric field: :class:`plask.flow.ModeLightEReceiver3D`
       Data filter for electric field: :class:`plask.flow.ModeLightEFilter3D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param int n: Number of the mode found with :meth:`find_mode`.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class ModeLightEProviderCyl(object):
    """
    ModeLightEProviderCyl(data)
    
    Provider of the electric field in Cylindrical2D geometry [V/m].
    
    This class is used for electric field provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outModeLightE(n=0, mesh, interpolation='default')
    
       :param int n: Number of the mode found with :meth:`find_mode`.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the electric field on the specified mesh **[V/m]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inModeLightE = solver.outModeLightE
    
       Obtain the provided field:
    
       >>> solver.outModeLightE(0, mesh)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outModeLightE)
       3
    
    See also:
       Receiver of electric field: :class:`plask.flow.ModeLightEReceiverCyl`
       Data filter for electric field: :class:`plask.flow.ModeLightEFilterCyl`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param int n: Number of the mode found with :meth:`find_mode`.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class ModeLightEReceiver2D(object):
    """
    ModeLightEReceiver2D()
    
    Receiver of the electric field in Cartesian2D geometry [V/m].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.ModeLightEProvider2D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inModeLightE = other_solver.outModeLightE
    
    See also:
       Provider of electric field: :class:`plask.flow.ModeLightEProvider2D`
    
       Data filter for electric field: :class:`plask.flow.ModeLightEFilter2D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inModeLightE.attach(300.)
               >>> solver.inModeLightE(any_mesh)[0]
               300.
               >>> solver.inModeLightE(any_mesh)[-1]
               300.
            
               >>> solver.inModeLightE.attach(other_solver.outModeLightE)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inModeLightE = other_solver.outModeLightE
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class ModeLightEReceiver3D(object):
    """
    ModeLightEReceiver3D()
    
    Receiver of the electric field in Cartesian3D geometry [V/m].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.ModeLightEProvider3D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inModeLightE = other_solver.outModeLightE
    
    See also:
       Provider of electric field: :class:`plask.flow.ModeLightEProvider3D`
    
       Data filter for electric field: :class:`plask.flow.ModeLightEFilter3D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inModeLightE.attach(300.)
               >>> solver.inModeLightE(any_mesh)[0]
               300.
               >>> solver.inModeLightE(any_mesh)[-1]
               300.
            
               >>> solver.inModeLightE.attach(other_solver.outModeLightE)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inModeLightE = other_solver.outModeLightE
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class ModeLightEReceiverCyl(object):
    """
    ModeLightEReceiverCyl()
    
    Receiver of the electric field in Cylindrical2D geometry [V/m].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.ModeLightEProviderCyl`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inModeLightE = other_solver.outModeLightE
    
    See also:
       Provider of electric field: :class:`plask.flow.ModeLightEProviderCyl`
    
       Data filter for electric field: :class:`plask.flow.ModeLightEFilterCyl`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inModeLightE.attach(300.)
               >>> solver.inModeLightE(any_mesh)[0]
               300.
               >>> solver.inModeLightE(any_mesh)[-1]
               300.
            
               >>> solver.inModeLightE.attach(other_solver.outModeLightE)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inModeLightE = other_solver.outModeLightE
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class ModeLightHFilter2D(plask.Solver):
    """
    ModeLightHFilter2D(geometry)
    
    Data filter for magnetic field into Cartesian2D geometry.
    
    Args:
        geometry (geometry.Cartesian2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inModeLightH = my_filter.out
    """



class ModeLightHFilter3D(plask.Solver):
    """
    ModeLightHFilter3D(geometry)
    
    Data filter for magnetic field into Cartesian3D geometry.
    
    Args:
        geometry (geometry.Cartesian3D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inModeLightH = my_filter.out
    """



class ModeLightHFilterCyl(plask.Solver):
    """
    ModeLightHFilterCyl(geometry)
    
    Data filter for magnetic field into Cylindrical2D geometry.
    
    Args:
        geometry (geometry.Cylindrical2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inModeLightH = my_filter.out
    """



class ModeLightHProvider2D(object):
    """
    ModeLightHProvider2D(data)
    
    Provider of the magnetic field in Cartesian2D geometry [A/m].
    
    This class is used for magnetic field provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outModeLightH(n=0, mesh, interpolation='default')
    
       :param int n: Number of the mode found with :meth:`find_mode`.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the magnetic field on the specified mesh **[A/m]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inModeLightH = solver.outModeLightH
    
       Obtain the provided field:
    
       >>> solver.outModeLightH(0, mesh)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outModeLightH)
       3
    
    See also:
       Receiver of magnetic field: :class:`plask.flow.ModeLightHReceiver2D`
       Data filter for magnetic field: :class:`plask.flow.ModeLightHFilter2D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param int n: Number of the mode found with :meth:`find_mode`.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class ModeLightHProvider3D(object):
    """
    ModeLightHProvider3D(data)
    
    Provider of the magnetic field in Cartesian3D geometry [A/m].
    
    This class is used for magnetic field provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outModeLightH(n=0, mesh, interpolation='default')
    
       :param int n: Number of the mode found with :meth:`find_mode`.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the magnetic field on the specified mesh **[A/m]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inModeLightH = solver.outModeLightH
    
       Obtain the provided field:
    
       >>> solver.outModeLightH(0, mesh)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outModeLightH)
       3
    
    See also:
       Receiver of magnetic field: :class:`plask.flow.ModeLightHReceiver3D`
       Data filter for magnetic field: :class:`plask.flow.ModeLightHFilter3D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param int n: Number of the mode found with :meth:`find_mode`.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class ModeLightHProviderCyl(object):
    """
    ModeLightHProviderCyl(data)
    
    Provider of the magnetic field in Cylindrical2D geometry [A/m].
    
    This class is used for magnetic field provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outModeLightH(n=0, mesh, interpolation='default')
    
       :param int n: Number of the mode found with :meth:`find_mode`.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the magnetic field on the specified mesh **[A/m]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inModeLightH = solver.outModeLightH
    
       Obtain the provided field:
    
       >>> solver.outModeLightH(0, mesh)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outModeLightH)
       3
    
    See also:
       Receiver of magnetic field: :class:`plask.flow.ModeLightHReceiverCyl`
       Data filter for magnetic field: :class:`plask.flow.ModeLightHFilterCyl`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param int n: Number of the mode found with :meth:`find_mode`.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class ModeLightHReceiver2D(object):
    """
    ModeLightHReceiver2D()
    
    Receiver of the magnetic field in Cartesian2D geometry [A/m].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.ModeLightHProvider2D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inModeLightH = other_solver.outModeLightH
    
    See also:
       Provider of magnetic field: :class:`plask.flow.ModeLightHProvider2D`
    
       Data filter for magnetic field: :class:`plask.flow.ModeLightHFilter2D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inModeLightH.attach(300.)
               >>> solver.inModeLightH(any_mesh)[0]
               300.
               >>> solver.inModeLightH(any_mesh)[-1]
               300.
            
               >>> solver.inModeLightH.attach(other_solver.outModeLightH)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inModeLightH = other_solver.outModeLightH
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class ModeLightHReceiver3D(object):
    """
    ModeLightHReceiver3D()
    
    Receiver of the magnetic field in Cartesian3D geometry [A/m].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.ModeLightHProvider3D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inModeLightH = other_solver.outModeLightH
    
    See also:
       Provider of magnetic field: :class:`plask.flow.ModeLightHProvider3D`
    
       Data filter for magnetic field: :class:`plask.flow.ModeLightHFilter3D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inModeLightH.attach(300.)
               >>> solver.inModeLightH(any_mesh)[0]
               300.
               >>> solver.inModeLightH(any_mesh)[-1]
               300.
            
               >>> solver.inModeLightH.attach(other_solver.outModeLightH)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inModeLightH = other_solver.outModeLightH
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class ModeLightHReceiverCyl(object):
    """
    ModeLightHReceiverCyl()
    
    Receiver of the magnetic field in Cylindrical2D geometry [A/m].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.ModeLightHProviderCyl`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inModeLightH = other_solver.outModeLightH
    
    See also:
       Provider of magnetic field: :class:`plask.flow.ModeLightHProviderCyl`
    
       Data filter for magnetic field: :class:`plask.flow.ModeLightHFilterCyl`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inModeLightH.attach(300.)
               >>> solver.inModeLightH(any_mesh)[0]
               300.
               >>> solver.inModeLightH(any_mesh)[-1]
               300.
            
               >>> solver.inModeLightH.attach(other_solver.outModeLightH)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inModeLightH = other_solver.outModeLightH
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class ModeLightMagnitudeFilter2D(plask.Solver):
    """
    ModeLightMagnitudeFilter2D(geometry)
    
    Data filter for optical field magnitude into Cartesian2D geometry.
    
    Args:
        geometry (geometry.Cartesian2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inModeLightMagnitude = my_filter.out
    """



class ModeLightMagnitudeFilter3D(plask.Solver):
    """
    ModeLightMagnitudeFilter3D(geometry)
    
    Data filter for optical field magnitude into Cartesian3D geometry.
    
    Args:
        geometry (geometry.Cartesian3D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inModeLightMagnitude = my_filter.out
    """



class ModeLightMagnitudeFilterCyl(plask.Solver):
    """
    ModeLightMagnitudeFilterCyl(geometry)
    
    Data filter for optical field magnitude into Cylindrical2D geometry.
    
    Args:
        geometry (geometry.Cylindrical2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inModeLightMagnitude = my_filter.out
    """



class ModeLightMagnitudeProvider2D(object):
    """
    ModeLightMagnitudeProvider2D(data)
    
    Provider of the optical field magnitude in Cartesian2D geometry [W/m²].
    
    This class is used for optical field magnitude provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outModeLightMagnitude(n=0, mesh, interpolation='default')
    
       :param int n: Number of the mode found with :meth:`find_mode`.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the optical field magnitude on the specified mesh **[W/m²]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inModeLightMagnitude = solver.outModeLightMagnitude
    
       Obtain the provided field:
    
       >>> solver.outModeLightMagnitude(0, mesh)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outModeLightMagnitude)
       3
    
    See also:
       Receiver of optical field magnitude: :class:`plask.flow.ModeLightMagnitudeReceiver2D`
       Data filter for optical field magnitude: :class:`plask.flow.ModeLightMagnitudeFilter2D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param int n: Number of the mode found with :meth:`find_mode`.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class ModeLightMagnitudeProvider3D(object):
    """
    ModeLightMagnitudeProvider3D(data)
    
    Provider of the optical field magnitude in Cartesian3D geometry [W/m²].
    
    This class is used for optical field magnitude provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outModeLightMagnitude(n=0, mesh, interpolation='default')
    
       :param int n: Number of the mode found with :meth:`find_mode`.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the optical field magnitude on the specified mesh **[W/m²]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inModeLightMagnitude = solver.outModeLightMagnitude
    
       Obtain the provided field:
    
       >>> solver.outModeLightMagnitude(0, mesh)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outModeLightMagnitude)
       3
    
    See also:
       Receiver of optical field magnitude: :class:`plask.flow.ModeLightMagnitudeReceiver3D`
       Data filter for optical field magnitude: :class:`plask.flow.ModeLightMagnitudeFilter3D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param int n: Number of the mode found with :meth:`find_mode`.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class ModeLightMagnitudeProviderCyl(object):
    """
    ModeLightMagnitudeProviderCyl(data)
    
    Provider of the optical field magnitude in Cylindrical2D geometry [W/m²].
    
    This class is used for optical field magnitude provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outModeLightMagnitude(n=0, mesh, interpolation='default')
    
       :param int n: Number of the mode found with :meth:`find_mode`.
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the optical field magnitude on the specified mesh **[W/m²]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inModeLightMagnitude = solver.outModeLightMagnitude
    
       Obtain the provided field:
    
       >>> solver.outModeLightMagnitude(0, mesh)
       <plask.Data at 0x1234567>
    
       Test the number of provided values:
    
       >>> len(solver.outModeLightMagnitude)
       3
    
    See also:
       Receiver of optical field magnitude: :class:`plask.flow.ModeLightMagnitudeReceiverCyl`
       Data filter for optical field magnitude: :class:`plask.flow.ModeLightMagnitudeFilterCyl`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param int n: Number of the mode found with :meth:`find_mode`.
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class ModeLightMagnitudeReceiver2D(object):
    """
    ModeLightMagnitudeReceiver2D()
    
    Receiver of the optical field magnitude in Cartesian2D geometry [W/m²].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.ModeLightMagnitudeProvider2D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inModeLightMagnitude = other_solver.outModeLightMagnitude
    
    See also:
       Provider of optical field magnitude: :class:`plask.flow.ModeLightMagnitudeProvider2D`
    
       Data filter for optical field magnitude: :class:`plask.flow.ModeLightMagnitudeFilter2D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inModeLightMagnitude.attach(300.)
               >>> solver.inModeLightMagnitude(any_mesh)[0]
               300.
               >>> solver.inModeLightMagnitude(any_mesh)[-1]
               300.
            
               >>> solver.inModeLightMagnitude.attach(other_solver.outModeLightMagnitude)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inModeLightMagnitude = other_solver.outModeLightMagnitude
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class ModeLightMagnitudeReceiver3D(object):
    """
    ModeLightMagnitudeReceiver3D()
    
    Receiver of the optical field magnitude in Cartesian3D geometry [W/m²].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.ModeLightMagnitudeProvider3D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inModeLightMagnitude = other_solver.outModeLightMagnitude
    
    See also:
       Provider of optical field magnitude: :class:`plask.flow.ModeLightMagnitudeProvider3D`
    
       Data filter for optical field magnitude: :class:`plask.flow.ModeLightMagnitudeFilter3D`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inModeLightMagnitude.attach(300.)
               >>> solver.inModeLightMagnitude(any_mesh)[0]
               300.
               >>> solver.inModeLightMagnitude(any_mesh)[-1]
               300.
            
               >>> solver.inModeLightMagnitude.attach(other_solver.outModeLightMagnitude)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inModeLightMagnitude = other_solver.outModeLightMagnitude
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class ModeLightMagnitudeReceiverCyl(object):
    """
    ModeLightMagnitudeReceiverCyl()
    
    Receiver of the optical field magnitude in Cylindrical2D geometry [W/m²].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.ModeLightMagnitudeProviderCyl`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inModeLightMagnitude = other_solver.outModeLightMagnitude
    
    See also:
       Provider of optical field magnitude: :class:`plask.flow.ModeLightMagnitudeProviderCyl`
    
       Data filter for optical field magnitude: :class:`plask.flow.ModeLightMagnitudeFilterCyl`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        __call__(self, n, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inModeLightMagnitude.attach(300.)
               >>> solver.inModeLightMagnitude(any_mesh)[0]
               300.
               >>> solver.inModeLightMagnitude(any_mesh)[-1]
               300.
            
               >>> solver.inModeLightMagnitude.attach(other_solver.outModeLightMagnitude)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inModeLightMagnitude = other_solver.outModeLightMagnitude
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class ModeLossProvider(object):
    """
    ModeLossProvider(data)
    
    Provider of the modal extinction [1/cm].
    
    This class is used for modal extinction provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: provided value or callable returning it on request.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outModeLoss(n=0)
    
       :param int n: Value number.
    
       
       :return: Value of the modal extinction **[1/cm]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inModeLoss = solver.outModeLoss
    
       Obtain the provided value:
    
       >>> solver.outModeLoss(0)
       1000
    
       Test the number of provided values:
    
       >>> len(solver.outModeLoss)
       3
    
    See also:
       Receiver of modal extinction: :class:`plask.flow.ModeLossReceiver`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self)
        __call__(self, n)
        
            Get value from the provider.
            
            :param int n: Value number.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class ModeLossReceiver(object):
    """
    ModeLossReceiver()
    
    Receiver of the modal extinction [1/cm].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.ModeLossProvider`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inModeLoss = other_solver.outModeLoss
    
    See also:
       Provider of modal extinction: :class:`plask.flow.ModeLossProvider`
    
       Data filter for modal extinction: :class:`plask.flow.ModeLossFilter`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self)
        __call__(self, n)
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inModeLoss.attach(300.)
               >>> solver.inModeLoss(any_mesh)[0]
               300.
               >>> solver.inModeLoss(any_mesh)[-1]
               300.
            
               >>> solver.inModeLoss.attach(other_solver.outModeLoss)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inModeLoss = other_solver.outModeLoss
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class ModePropagationConstantProvider(object):
    """
    ModePropagationConstantProvider(data)
    
    Provider of the propagation constant [1/µm].
    
    This class is used for propagation constant provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: provided value or callable returning it on request.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outModePropagationConstant(n=0)
    
       :param int n: Value number.
    
       
       :return: Value of the propagation constant **[1/µm]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inModePropagationConstant = solver.outModePropagationConstant
    
       Obtain the provided value:
    
       >>> solver.outModePropagationConstant(0)
       1000
    
       Test the number of provided values:
    
       >>> len(solver.outModePropagationConstant)
       3
    
    See also:
       Receiver of propagation constant: :class:`plask.flow.ModePropagationConstantReceiver`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self)
        __call__(self, n)
        
            Get value from the provider.
            
            :param int n: Value number.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class ModePropagationConstantReceiver(object):
    """
    ModePropagationConstantReceiver()
    
    Receiver of the propagation constant [1/µm].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.ModePropagationConstantProvider`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inModePropagationConstant = other_solver.outModePropagationConstant
    
    See also:
       Provider of propagation constant: :class:`plask.flow.ModePropagationConstantProvider`
    
       Data filter for propagation constant: :class:`plask.flow.ModePropagationConstantFilter`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self)
        __call__(self, n)
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inModePropagationConstant.attach(300.)
               >>> solver.inModePropagationConstant(any_mesh)[0]
               300.
               >>> solver.inModePropagationConstant(any_mesh)[-1]
               300.
            
               >>> solver.inModePropagationConstant.attach(other_solver.outModePropagationConstant)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inModePropagationConstant = other_solver.outModePropagationConstant
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class ModeWavelengthProvider(object):
    """
    ModeWavelengthProvider(data)
    
    Provider of the wavelength [nm].
    
    This class is used for wavelength provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: provided value or callable returning it on request.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below). It must also be able to give its
           length (i.e. have the ``__len__`` method defined) that gives the
           number of different provided values.
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outModeWavelength(n=0)
    
       :param int n: Value number.
    
       
       :return: Value of the wavelength **[nm]**.
    
    You may obtain the number of different values this provider can return by
    testing its length.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inModeWavelength = solver.outModeWavelength
    
       Obtain the provided value:
    
       >>> solver.outModeWavelength(0)
       1000
    
       Test the number of provided values:
    
       >>> len(solver.outModeWavelength)
       3
    
    See also:
       Receiver of wavelength: :class:`plask.flow.ModeWavelengthReceiver`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self)
        __call__(self, n)
        
            Get value from the provider.
            
            :param int n: Value number.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class ModeWavelengthReceiver(object):
    """
    ModeWavelengthReceiver()
    
    Receiver of the wavelength [nm].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.ModeWavelengthProvider`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inModeWavelength = other_solver.outModeWavelength
    
    See also:
       Provider of wavelength: :class:`plask.flow.ModeWavelengthProvider`
    
       Data filter for wavelength: :class:`plask.flow.ModeWavelengthFilter`
    """
    def __call__(*args, **kwargs):
        """
        __call__(self)
        __call__(self, n)
        
            Get value from the connected provider
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inModeWavelength.attach(300.)
               >>> solver.inModeWavelength(any_mesh)[0]
               300.
               >>> solver.inModeWavelength(any_mesh)[-1]
               300.
            
               >>> solver.inModeWavelength.attach(other_solver.outModeWavelength)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inModeWavelength = other_solver.outModeWavelength
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class PotentialFilter2D(plask.Solver):
    """
    PotentialFilter2D(geometry)
    
    Data filter for potential into Cartesian2D geometry.
    
    Args:
        geometry (geometry.Cartesian2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inPotential = my_filter.out
    """



class PotentialFilter3D(plask.Solver):
    """
    PotentialFilter3D(geometry)
    
    Data filter for potential into Cartesian3D geometry.
    
    Args:
        geometry (geometry.Cartesian3D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inPotential = my_filter.out
    """



class PotentialFilterCyl(plask.Solver):
    """
    PotentialFilterCyl(geometry)
    
    Data filter for potential into Cylindrical2D geometry.
    
    Args:
        geometry (geometry.Cylindrical2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inPotential = my_filter.out
    """



class PotentialProvider2D(object):
    """
    PotentialProvider2D(data)
    
    Provider of the potential in Cartesian2D geometry [V].
    
    This class is used for potential provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outPotential(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the potential on the specified mesh **[V]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inPotential = solver.outPotential
    
       Obtain the provided field:
    
       >>> solver.outPotential(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of potential: :class:`plask.flow.PotentialReceiver2D`
       Data filter for potential: :class:`plask.flow.PotentialFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class PotentialProvider3D(object):
    """
    PotentialProvider3D(data)
    
    Provider of the potential in Cartesian3D geometry [V].
    
    This class is used for potential provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outPotential(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the potential on the specified mesh **[V]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inPotential = solver.outPotential
    
       Obtain the provided field:
    
       >>> solver.outPotential(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of potential: :class:`plask.flow.PotentialReceiver3D`
       Data filter for potential: :class:`plask.flow.PotentialFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class PotentialProviderCyl(object):
    """
    PotentialProviderCyl(data)
    
    Provider of the potential in Cylindrical2D geometry [V].
    
    This class is used for potential provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outPotential(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the potential on the specified mesh **[V]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inPotential = solver.outPotential
    
       Obtain the provided field:
    
       >>> solver.outPotential(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of potential: :class:`plask.flow.PotentialReceiverCyl`
       Data filter for potential: :class:`plask.flow.PotentialFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class PotentialReceiver2D(object):
    """
    PotentialReceiver2D()
    
    Receiver of the potential in Cartesian2D geometry [V].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.PotentialProvider2D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inPotential = other_solver.outPotential
    
    See also:
       Provider of potential: :class:`plask.flow.PotentialProvider2D`
    
       Data filter for potential: :class:`plask.flow.PotentialFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inPotential.attach(300.)
               >>> solver.inPotential(any_mesh)[0]
               300.
               >>> solver.inPotential(any_mesh)[-1]
               300.
            
               >>> solver.inPotential.attach(other_solver.outPotential)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inPotential = other_solver.outPotential
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class PotentialReceiver3D(object):
    """
    PotentialReceiver3D()
    
    Receiver of the potential in Cartesian3D geometry [V].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.PotentialProvider3D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inPotential = other_solver.outPotential
    
    See also:
       Provider of potential: :class:`plask.flow.PotentialProvider3D`
    
       Data filter for potential: :class:`plask.flow.PotentialFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inPotential.attach(300.)
               >>> solver.inPotential(any_mesh)[0]
               300.
               >>> solver.inPotential(any_mesh)[-1]
               300.
            
               >>> solver.inPotential.attach(other_solver.outPotential)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inPotential = other_solver.outPotential
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class PotentialReceiverCyl(object):
    """
    PotentialReceiverCyl()
    
    Receiver of the potential in Cylindrical2D geometry [V].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.PotentialProviderCyl`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inPotential = other_solver.outPotential
    
    See also:
       Provider of potential: :class:`plask.flow.PotentialProviderCyl`
    
       Data filter for potential: :class:`plask.flow.PotentialFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inPotential.attach(300.)
               >>> solver.inPotential(any_mesh)[0]
               300.
               >>> solver.inPotential(any_mesh)[-1]
               300.
            
               >>> solver.inPotential.attach(other_solver.outPotential)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inPotential = other_solver.outPotential
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class RefractiveIndexFilter2D(plask.Solver):
    """
    RefractiveIndexFilter2D(geometry)
    
    Data filter for refractive index into Cartesian2D geometry.
    
    Args:
        geometry (geometry.Cartesian2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inRefractiveIndex = my_filter.out
    """



class RefractiveIndexFilter3D(plask.Solver):
    """
    RefractiveIndexFilter3D(geometry)
    
    Data filter for refractive index into Cartesian3D geometry.
    
    Args:
        geometry (geometry.Cartesian3D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inRefractiveIndex = my_filter.out
    """



class RefractiveIndexFilterCyl(plask.Solver):
    """
    RefractiveIndexFilterCyl(geometry)
    
    Data filter for refractive index into Cylindrical2D geometry.
    
    Args:
        geometry (geometry.Cylindrical2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inRefractiveIndex = my_filter.out
    """



class RefractiveIndexProvider2D(object):
    """
    RefractiveIndexProvider2D(data)
    
    Provider of the refractive index in Cartesian2D geometry [-].
    
    This class is used for refractive index provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outRefractiveIndex(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the refractive index on the specified mesh **[-]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inRefractiveIndex = solver.outRefractiveIndex
    
       Obtain the provided field:
    
       >>> solver.outRefractiveIndex(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of refractive index: :class:`plask.flow.RefractiveIndexReceiver2D`
       Data filter for refractive index: :class:`plask.flow.RefractiveIndexFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class RefractiveIndexProvider3D(object):
    """
    RefractiveIndexProvider3D(data)
    
    Provider of the refractive index in Cartesian3D geometry [-].
    
    This class is used for refractive index provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outRefractiveIndex(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the refractive index on the specified mesh **[-]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inRefractiveIndex = solver.outRefractiveIndex
    
       Obtain the provided field:
    
       >>> solver.outRefractiveIndex(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of refractive index: :class:`plask.flow.RefractiveIndexReceiver3D`
       Data filter for refractive index: :class:`plask.flow.RefractiveIndexFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class RefractiveIndexProviderCyl(object):
    """
    RefractiveIndexProviderCyl(data)
    
    Provider of the refractive index in Cylindrical2D geometry [-].
    
    This class is used for refractive index provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outRefractiveIndex(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the refractive index on the specified mesh **[-]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inRefractiveIndex = solver.outRefractiveIndex
    
       Obtain the provided field:
    
       >>> solver.outRefractiveIndex(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of refractive index: :class:`plask.flow.RefractiveIndexReceiverCyl`
       Data filter for refractive index: :class:`plask.flow.RefractiveIndexFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class RefractiveIndexReceiver2D(object):
    """
    RefractiveIndexReceiver2D()
    
    Receiver of the refractive index in Cartesian2D geometry [-].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.RefractiveIndexProvider2D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inRefractiveIndex = other_solver.outRefractiveIndex
    
    See also:
       Provider of refractive index: :class:`plask.flow.RefractiveIndexProvider2D`
    
       Data filter for refractive index: :class:`plask.flow.RefractiveIndexFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inRefractiveIndex.attach(300.)
               >>> solver.inRefractiveIndex(any_mesh)[0]
               300.
               >>> solver.inRefractiveIndex(any_mesh)[-1]
               300.
            
               >>> solver.inRefractiveIndex.attach(other_solver.outRefractiveIndex)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inRefractiveIndex = other_solver.outRefractiveIndex
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class RefractiveIndexReceiver3D(object):
    """
    RefractiveIndexReceiver3D()
    
    Receiver of the refractive index in Cartesian3D geometry [-].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.RefractiveIndexProvider3D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inRefractiveIndex = other_solver.outRefractiveIndex
    
    See also:
       Provider of refractive index: :class:`plask.flow.RefractiveIndexProvider3D`
    
       Data filter for refractive index: :class:`plask.flow.RefractiveIndexFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inRefractiveIndex.attach(300.)
               >>> solver.inRefractiveIndex(any_mesh)[0]
               300.
               >>> solver.inRefractiveIndex(any_mesh)[-1]
               300.
            
               >>> solver.inRefractiveIndex.attach(other_solver.outRefractiveIndex)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inRefractiveIndex = other_solver.outRefractiveIndex
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class RefractiveIndexReceiverCyl(object):
    """
    RefractiveIndexReceiverCyl()
    
    Receiver of the refractive index in Cylindrical2D geometry [-].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.RefractiveIndexProviderCyl`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inRefractiveIndex = other_solver.outRefractiveIndex
    
    See also:
       Provider of refractive index: :class:`plask.flow.RefractiveIndexProviderCyl`
    
       Data filter for refractive index: :class:`plask.flow.RefractiveIndexFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inRefractiveIndex.attach(300.)
               >>> solver.inRefractiveIndex(any_mesh)[0]
               300.
               >>> solver.inRefractiveIndex(any_mesh)[-1]
               300.
            
               >>> solver.inRefractiveIndex.attach(other_solver.outRefractiveIndex)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inRefractiveIndex = other_solver.outRefractiveIndex
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class TemperatureFilter2D(plask.Solver):
    """
    TemperatureFilter2D(geometry)
    
    Data filter for temperature into Cartesian2D geometry.
    
    Args:
        geometry (geometry.Cartesian2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inTemperature = my_filter.out
    """



class TemperatureFilter3D(plask.Solver):
    """
    TemperatureFilter3D(geometry)
    
    Data filter for temperature into Cartesian3D geometry.
    
    Args:
        geometry (geometry.Cartesian3D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inTemperature = my_filter.out
    """



class TemperatureFilterCyl(plask.Solver):
    """
    TemperatureFilterCyl(geometry)
    
    Data filter for temperature into Cylindrical2D geometry.
    
    Args:
        geometry (geometry.Cylindrical2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inTemperature = my_filter.out
    """



class TemperatureProvider2D(object):
    """
    TemperatureProvider2D(data)
    
    Provider of the temperature in Cartesian2D geometry [K].
    
    This class is used for temperature provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outTemperature(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the temperature on the specified mesh **[K]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inTemperature = solver.outTemperature
    
       Obtain the provided field:
    
       >>> solver.outTemperature(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of temperature: :class:`plask.flow.TemperatureReceiver2D`
       Data filter for temperature: :class:`plask.flow.TemperatureFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class TemperatureProvider3D(object):
    """
    TemperatureProvider3D(data)
    
    Provider of the temperature in Cartesian3D geometry [K].
    
    This class is used for temperature provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outTemperature(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the temperature on the specified mesh **[K]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inTemperature = solver.outTemperature
    
       Obtain the provided field:
    
       >>> solver.outTemperature(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of temperature: :class:`plask.flow.TemperatureReceiver3D`
       Data filter for temperature: :class:`plask.flow.TemperatureFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class TemperatureProviderCyl(object):
    """
    TemperatureProviderCyl(data)
    
    Provider of the temperature in Cylindrical2D geometry [K].
    
    This class is used for temperature provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outTemperature(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the temperature on the specified mesh **[K]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inTemperature = solver.outTemperature
    
       Obtain the provided field:
    
       >>> solver.outTemperature(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of temperature: :class:`plask.flow.TemperatureReceiverCyl`
       Data filter for temperature: :class:`plask.flow.TemperatureFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class TemperatureReceiver2D(object):
    """
    TemperatureReceiver2D()
    
    Receiver of the temperature in Cartesian2D geometry [K].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.TemperatureProvider2D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inTemperature = other_solver.outTemperature
    
    See also:
       Provider of temperature: :class:`plask.flow.TemperatureProvider2D`
    
       Data filter for temperature: :class:`plask.flow.TemperatureFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inTemperature.attach(300.)
               >>> solver.inTemperature(any_mesh)[0]
               300.
               >>> solver.inTemperature(any_mesh)[-1]
               300.
            
               >>> solver.inTemperature.attach(other_solver.outTemperature)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inTemperature = other_solver.outTemperature
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class TemperatureReceiver3D(object):
    """
    TemperatureReceiver3D()
    
    Receiver of the temperature in Cartesian3D geometry [K].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.TemperatureProvider3D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inTemperature = other_solver.outTemperature
    
    See also:
       Provider of temperature: :class:`plask.flow.TemperatureProvider3D`
    
       Data filter for temperature: :class:`plask.flow.TemperatureFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inTemperature.attach(300.)
               >>> solver.inTemperature(any_mesh)[0]
               300.
               >>> solver.inTemperature(any_mesh)[-1]
               300.
            
               >>> solver.inTemperature.attach(other_solver.outTemperature)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inTemperature = other_solver.outTemperature
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class TemperatureReceiverCyl(object):
    """
    TemperatureReceiverCyl()
    
    Receiver of the temperature in Cylindrical2D geometry [K].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.TemperatureProviderCyl`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inTemperature = other_solver.outTemperature
    
    See also:
       Provider of temperature: :class:`plask.flow.TemperatureProviderCyl`
    
       Data filter for temperature: :class:`plask.flow.TemperatureFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inTemperature.attach(300.)
               >>> solver.inTemperature(any_mesh)[0]
               300.
               >>> solver.inTemperature(any_mesh)[-1]
               300.
            
               >>> solver.inTemperature.attach(other_solver.outTemperature)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inTemperature = other_solver.outTemperature
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class ThermalConductivityFilter2D(plask.Solver):
    """
    ThermalConductivityFilter2D(geometry)
    
    Data filter for thermal conductivity into Cartesian2D geometry.
    
    Args:
        geometry (geometry.Cartesian2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inThermalConductivity = my_filter.out
    """



class ThermalConductivityFilter3D(plask.Solver):
    """
    ThermalConductivityFilter3D(geometry)
    
    Data filter for thermal conductivity into Cartesian3D geometry.
    
    Args:
        geometry (geometry.Cartesian3D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inThermalConductivity = my_filter.out
    """



class ThermalConductivityFilterCyl(plask.Solver):
    """
    ThermalConductivityFilterCyl(geometry)
    
    Data filter for thermal conductivity into Cylindrical2D geometry.
    
    Args:
        geometry (geometry.Cylindrical2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inThermalConductivity = my_filter.out
    """



class ThermalConductivityProvider2D(object):
    """
    ThermalConductivityProvider2D(data)
    
    Provider of the thermal conductivity in Cartesian2D geometry [W/(m×K)].
    
    This class is used for thermal conductivity provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outThermalConductivity(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the thermal conductivity on the specified mesh **[W/(m×K)]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inThermalConductivity = solver.outThermalConductivity
    
       Obtain the provided field:
    
       >>> solver.outThermalConductivity(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of thermal conductivity: :class:`plask.flow.ThermalConductivityReceiver2D`
       Data filter for thermal conductivity: :class:`plask.flow.ThermalConductivityFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class ThermalConductivityProvider3D(object):
    """
    ThermalConductivityProvider3D(data)
    
    Provider of the thermal conductivity in Cartesian3D geometry [W/(m×K)].
    
    This class is used for thermal conductivity provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outThermalConductivity(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the thermal conductivity on the specified mesh **[W/(m×K)]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inThermalConductivity = solver.outThermalConductivity
    
       Obtain the provided field:
    
       >>> solver.outThermalConductivity(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of thermal conductivity: :class:`plask.flow.ThermalConductivityReceiver3D`
       Data filter for thermal conductivity: :class:`plask.flow.ThermalConductivityFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class ThermalConductivityProviderCyl(object):
    """
    ThermalConductivityProviderCyl(data)
    
    Provider of the thermal conductivity in Cylindrical2D geometry [W/(m×K)].
    
    This class is used for thermal conductivity provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outThermalConductivity(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the thermal conductivity on the specified mesh **[W/(m×K)]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inThermalConductivity = solver.outThermalConductivity
    
       Obtain the provided field:
    
       >>> solver.outThermalConductivity(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of thermal conductivity: :class:`plask.flow.ThermalConductivityReceiverCyl`
       Data filter for thermal conductivity: :class:`plask.flow.ThermalConductivityFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class ThermalConductivityReceiver2D(object):
    """
    ThermalConductivityReceiver2D()
    
    Receiver of the thermal conductivity in Cartesian2D geometry [W/(m×K)].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.ThermalConductivityProvider2D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inThermalConductivity = other_solver.outThermalConductivity
    
    See also:
       Provider of thermal conductivity: :class:`plask.flow.ThermalConductivityProvider2D`
    
       Data filter for thermal conductivity: :class:`plask.flow.ThermalConductivityFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inThermalConductivity.attach(300.)
               >>> solver.inThermalConductivity(any_mesh)[0]
               300.
               >>> solver.inThermalConductivity(any_mesh)[-1]
               300.
            
               >>> solver.inThermalConductivity.attach(other_solver.outThermalConductivity)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inThermalConductivity = other_solver.outThermalConductivity
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class ThermalConductivityReceiver3D(object):
    """
    ThermalConductivityReceiver3D()
    
    Receiver of the thermal conductivity in Cartesian3D geometry [W/(m×K)].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.ThermalConductivityProvider3D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inThermalConductivity = other_solver.outThermalConductivity
    
    See also:
       Provider of thermal conductivity: :class:`plask.flow.ThermalConductivityProvider3D`
    
       Data filter for thermal conductivity: :class:`plask.flow.ThermalConductivityFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inThermalConductivity.attach(300.)
               >>> solver.inThermalConductivity(any_mesh)[0]
               300.
               >>> solver.inThermalConductivity(any_mesh)[-1]
               300.
            
               >>> solver.inThermalConductivity.attach(other_solver.outThermalConductivity)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inThermalConductivity = other_solver.outThermalConductivity
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class ThermalConductivityReceiverCyl(object):
    """
    ThermalConductivityReceiverCyl()
    
    Receiver of the thermal conductivity in Cylindrical2D geometry [W/(m×K)].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.ThermalConductivityProviderCyl`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inThermalConductivity = other_solver.outThermalConductivity
    
    See also:
       Provider of thermal conductivity: :class:`plask.flow.ThermalConductivityProviderCyl`
    
       Data filter for thermal conductivity: :class:`plask.flow.ThermalConductivityFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inThermalConductivity.attach(300.)
               >>> solver.inThermalConductivity(any_mesh)[0]
               300.
               >>> solver.inThermalConductivity(any_mesh)[-1]
               300.
            
               >>> solver.inThermalConductivity.attach(other_solver.outThermalConductivity)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inThermalConductivity = other_solver.outThermalConductivity
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class VoltageFilter2D(plask.Solver):
    """
    VoltageFilter2D(geometry)
    
    Data filter for voltage into Cartesian2D geometry.
    
    Args:
        geometry (geometry.Cartesian2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inVoltage = my_filter.out
    """



class VoltageFilter3D(plask.Solver):
    """
    VoltageFilter3D(geometry)
    
    Data filter for voltage into Cartesian3D geometry.
    
    Args:
        geometry (geometry.Cartesian3D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inVoltage = my_filter.out
    """



class VoltageFilterCyl(plask.Solver):
    """
    VoltageFilterCyl(geometry)
    
    Data filter for voltage into Cylindrical2D geometry.
    
    Args:
        geometry (geometry.Cylindrical2D): Target geometry.
    
    See also:
        :mod:`plask.filter` for details on filter usage.
    """
    id = None
    """
    Id of the solver object. (read only)
    
    Example:
        >>> mysolver.id
        mysolver:category.type
    """

    def initialize(self):
        """
        initialize(self)
        
            Initialize solver.
            
            This method manually initialized the solver and sets :attr:`initialized` to
            *True*. Normally calling it is not necessary, as each solver automatically
            initializes itself when needed.
            
            Returns:
                bool: solver :attr:`initialized` state prior to this method call.
        """

    initialized = None
    """
    True if the solver has been initialized. (read only)
    
    Solvers usually get initialized at the beginning of the computations.
    You can clean the initialization state and free the memory by calling
    the :meth:`invalidate` method.
    """

    def invalidate(self):
        """
        invalidate(self)
        
            Set the solver back to uninitialized state.
            
            This method frees the memory allocated by the solver and sets
            :attr:`initialized` to *False*.
        """

    def load_xpl(self, xpl, manager):
        """
        load_xpl(self, xpl, manager)
        
            Load configuration from XPL reader.
            
            This method should be overriden in custom Python solvers.
            
            Example:
              .. code-block:: python
            
                 def load_xpl(self, xpl, manager):
                     for tag in xpl:
                         if tag == 'config':
                             self.a = tag['a']
                             self.b = tag.get('b', 0)
                             if 'c' in tag:
                                 self.c = tag['c']
                         if tag == 'combined':
                             for subtag in tag:
                                 if subtag == 'withtext':
                                     self.data = subtag.attrs
                                     # Text must be read last
                                     self.text = subtag.text
                         elif tag == 'geometry':
                             self.geometry = tag.getitem(manager.geo, 'ref')
        """

    out = None
    """
    Filter output provider.
    
    Example:
        >>> some_solver.inVoltage = my_filter.out
    """



class VoltageProvider2D(object):
    """
    VoltageProvider2D(data)
    
    Provider of the voltage in Cartesian2D geometry [V].
    
    This class is used for voltage provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outVoltage(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the voltage on the specified mesh **[V]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inVoltage = solver.outVoltage
    
       Obtain the provided field:
    
       >>> solver.outVoltage(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of voltage: :class:`plask.flow.VoltageReceiver2D`
       Data filter for voltage: :class:`plask.flow.VoltageFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class VoltageProvider3D(object):
    """
    VoltageProvider3D(data)
    
    Provider of the voltage in Cartesian3D geometry [V].
    
    This class is used for voltage provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outVoltage(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the voltage on the specified mesh **[V]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inVoltage = solver.outVoltage
    
       Obtain the provided field:
    
       >>> solver.outVoltage(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of voltage: :class:`plask.flow.VoltageReceiver3D`
       Data filter for voltage: :class:`plask.flow.VoltageFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class VoltageProviderCyl(object):
    """
    VoltageProviderCyl(data)
    
    Provider of the voltage in Cylindrical2D geometry [V].
    
    This class is used for voltage provider in binary solvers.
    You can also create a custom provider for your Python solver.
    
    Args:
       data: ``Data`` object to interpolate or callable returning it for given mesh.
           The callable must accept the same arguments as the provider
           ``__call__`` method (see below).
    
    To obtain the value from the provider simply call it. The call signature
    is as follows:
    
    .. method:: solver.outVoltage(mesh, interpolation='default')
    
       :param mesh mesh: Target mesh to get the field at.
       :param str interpolation: Requested interpolation method.
       
       :return: Data with the voltage on the specified mesh **[V]**.
    
    Example:
       Connect the provider to a receiver in some other solver:
    
       >>> other_solver.inVoltage = solver.outVoltage
    
       Obtain the provided field:
    
       >>> solver.outVoltage(mesh)
       <plask.Data at 0x1234567>
    
    See also:
       Receiver of voltage: :class:`plask.flow.VoltageReceiverCyl`
       Data filter for voltage: :class:`plask.flow.VoltageFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the provider.
            
            :param mesh mesh: Target mesh to get the field at.
            :param str interpolation: Requested interpolation method.
        """

    def set_changed(self):
        """
        set_changed(self)
        
            Inform all connected receivers that the provided value has changed.
            
            The receivers will have its `changed` attribute set to True and solvers will
            call the provider again if they need its value (otherwise they might take it
            from the cache.
        """



class VoltageReceiver2D(object):
    """
    VoltageReceiver2D()
    
    Receiver of the voltage in Cartesian2D geometry [V].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.VoltageProvider2D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inVoltage = other_solver.outVoltage
    
    See also:
       Provider of voltage: :class:`plask.flow.VoltageProvider2D`
    
       Data filter for voltage: :class:`plask.flow.VoltageFilter2D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inVoltage.attach(300.)
               >>> solver.inVoltage(any_mesh)[0]
               300.
               >>> solver.inVoltage(any_mesh)[-1]
               300.
            
               >>> solver.inVoltage.attach(other_solver.outVoltage)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inVoltage = other_solver.outVoltage
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class VoltageReceiver3D(object):
    """
    VoltageReceiver3D()
    
    Receiver of the voltage in Cartesian3D geometry [V].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.VoltageProvider3D`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inVoltage = other_solver.outVoltage
    
    See also:
       Provider of voltage: :class:`plask.flow.VoltageProvider3D`
    
       Data filter for voltage: :class:`plask.flow.VoltageFilter3D`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inVoltage.attach(300.)
               >>> solver.inVoltage(any_mesh)[0]
               300.
               >>> solver.inVoltage(any_mesh)[-1]
               300.
            
               >>> solver.inVoltage.attach(other_solver.outVoltage)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inVoltage = other_solver.outVoltage
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """



class VoltageReceiverCyl(object):
    """
    VoltageReceiverCyl()
    
    Receiver of the voltage in Cylindrical2D geometry [V].
    
    You may connect a provider to this receiver usign either the `connect` method
    or an assignement operator. Then, you can read the provided value by calling
    this receiver with arguments identical as the ones of the corresponding
    provider :class:`~plask.flow.VoltageProviderCyl`.
    
    Example:
       Connect the reveiver to a provider from some other solver:
    
       >>> solver.inVoltage = other_solver.outVoltage
    
    See also:
       Provider of voltage: :class:`plask.flow.VoltageProviderCyl`
    
       Data filter for voltage: :class:`plask.flow.VoltageFilterCyl`
    """
    def __call__(self, mesh, interpolation='DEFAULT'):
        """
        __call__(self, mesh, interpolation='DEFAULT')
        
            Get value from the connected provider
        """

    def attach(self, source):
        """
        attach(self, source)
        
            Attach some provider or constant value to the receiver.
            
            Args:
                source: source provider or value.
            
            Example:
               >>> solver.inVoltage.attach(300.)
               >>> solver.inVoltage(any_mesh)[0]
               300.
               >>> solver.inVoltage(any_mesh)[-1]
               300.
            
               >>> solver.inVoltage.attach(other_solver.outVoltage)
            
            Note:
               You may achieve the same effect by using the asignmnent operator
               if you put an exisiting provider at the right side of this operator:
            
               >>> solver.inVoltage = other_solver.outVoltage
        """

    def reset(self):
        """
        reset(self)
        
            Disconnect any provider of value from the receiver.
        """

