docs: 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