operation for 3D Field with planes or vector (type = numpy.ndarray) or 2D Field with vector (numpy.ndarray)
        :param f: operator function
        :param x: array(1D, 2D) or field (2D) or View (2D)
        :param axis: specifies axis, eg. axis = (1,2) plane lies in yz-plane, axis=0 vector along x axis
        :return: dict with result of operation (same form as field.d)

def __array_op(self, f, x, axis):
        """operation for 3D Field with planes or vector (type = numpy.ndarray) or 2D Field with vector (numpy.ndarray)
        :param f: operator function
        :param x: array(1D, 2D) or field (2D) or View (2D)
        :param axis: specifies axis, eg. axis = (1,2) plane lies in yz-plane, axis=0 vector along x axis
        :return: dict with result of operation (same form as field.d)
        """
        if isinstance(x, ndarray) == False and isinstance(x, Field) == False and isinstance(x, View) == False:
            raise ValueError('first argument has to be an array of dimension 1 or 2 or an Field or an View of dimension 2')

        d = {}
        #x is a vector (only numpy ndarray)
        if isinstance(axis, int) and isinstance(x, ndarray):
            if len(self.__partition.mesh.bounds[0]) == 3:

                try:

                    for i in self.__d:
                        try:
                            ind = self.__indices(self.partition.meta_data[i], self.__mask)
                        except:
                            raise ValueError("Indices geht nicht.")

                        if axis == 0:
                            d[i] = f(self.__d[i], x[ind[0]][:, newaxis, newaxis])
                        elif axis == 1:
                            d[i] = f(self.__d[i], x[ind[1]][:, newaxis])
                        elif axis == 2:
                            d[i] = f(self.__d[i], x[ind[2]])
                        else:
                            raise ValueError('"axis" can only have value 0, 1 or 2 .')
                        self.__d[i][:] = d[i][:]
                except:
                    raise ValueError('Vector does not have same length as Field along axis %d.' %axis)
            elif len(self.__partition.mesh.bounds[0]) == 2:
                try:
                    for i in self.__d:
                        ind = self.__indices(self.partition.meta_data[i], self.__mask)
                        if axis == 0:
                            d[i] = f(self.__d[i], x[ind[0]][:, newaxis])
                        elif axis == 1:
                            d[i] = f(self.__d[i], x[ind[1]][:])
                        else:
                            raise ValueError('"axis" can only have value 0 or 2 .')
                        self.__d[i][:] = d[i][:]
                except: raise ValueError('Vector does not have same length as Field along axis %d.' %axis)
        #x is a plane (2D-numpy.ndarray or 2D field or View with same partitions, shape and bounds in plane as 3D field)
        elif len(axis) == 2:
            #operation for 2D-arrays
            if isinstance(x, ndarray):
                try:
                    for i in self.__d:
                        ind = self.__indices(self.partition.meta_data[i], self.__mask)
                        if axis == (0, 1) or axis == (1, 0):
                            d[i] = f(self.__d[i], x[ind[0], ind[1]][:, :, newaxis])
                        elif axis == (1, 2) or axis == (2, 1):
                            d[i] = f(self.__d[i], x[ind[1], ind[2]])
                        elif axis == (0, 2) or axis == (2, 0):
                            d[i] = f(self.__d[i], x[ind[0], ind[2]][:, newaxis, :])
                        else:
                            raise ValueError('Axis-tuple can only contain 0 (x-axis), 1 (y-axis) and 2 (z-axis).')
                        self.__d[i][:] = d[i][:]
                except: raise ValueError('2D-Array does not fit to plane %s of Field' %(axis,))
            #operation for 2D Fields or View (Field from same origin mesh but bounds like View has)
            elif isinstance(x, Field) or isinstance(x, View):
                if axis == (0, 1) or axis == (1, 0):
                    try:
                        for i in self.__d: d[i] = f(self.__d[i], x.d[(i[0],i[1])][:, :, newaxis])
                    except: raise ValueError('2D-Field/-View does not fit to field in xy-plane (maybe whole shape or partitions does not fit)')
                elif axis == (1, 2) or axis == (2, 1):
                    try:
                        for i in self.__d: d[i] = f(self.__d[i], x.d[(i[1],i[2])])
                    except: raise ValueError('2D-Field/-View does not fit to field in yz-plane (maybe whole shape or partitions does not fit)')
                elif axis == (0, 2) or axis == (2, 0):
                    try:
                        for i in self.__d: d[i] = f(self.__d[i], x.d[(i[0],i[2])][:, newaxis, :])
                    except: raise ValueError('2D-Field/-View does not fit to field in xz-plane (maybe whole shape or partitions does not fit)')
                else: raise ValueError('Axis-tuple can only contain 0 (x-axis), 1 (y-axis) and 2 (z-axis).')
            else: raise ValueError('x has to be an Field, View or numpy.ndarray with 2 dimensions (or an 1D numpy.ndarray (vector))')

        else: raise ValueError('Argument "axis" has to be an integer (for vector) or tuple of length 2 (for 2D array or field)')

        return d