docs: def refocus_stack(fieldstack, d, nm, res, method="helmholtz",
                    num_cpus=_cpu_count, copy=True, padding=True):
      """Refocus a stack of 1D or 2D fields
  
  
      Parameters
      ----------
      fieldstack : 2d or 3d array
          Stack of 1D or 2D background corrected electric fields (Ex/BEx).
          The first axis iterates through the individual fields.
      d : float
          Distance to be propagated in pixels (negative for backwards)
      nm : float
          Refractive index of medium
      res : float
          Wavelenth in pixels
      method : str
          Defines the method of propagation;
          one of
  
              - "helmholtz" : the optical transfer function `exp(idkₘ(M-1))`
              - "fresnel"   : paraxial approximation `exp(idk²/kₘ)`
  
      num_cpus : str
          Defines the number of CPUs to be used for refocusing.
      copy : bool
          If False, overwrites input stack.
      padding : bool
          Perform padding with linear ramp from edge to average
          to reduce ringing artifacts.
  
          .. versionadded:: 0.1.4
  
      Returns
      -------
      Electric field stack at `d`.
      """
  
      func = refocus
      names = func.__code__.co_varnames[:func.__code__.co_argcount]
  
      loc = locals()
      vardict = dict()
      for name in names:
          if name in loc.keys():
              vardict[name] = loc[name]
      # default keyword arguments
      func_def = func.__defaults__[::-1]
  
      # child processes should only use one cpu
      vardict["num_cpus"] = 1
      vardict["padding"] = padding
  
      M = fieldstack.shape[0]
      stackargs = list()
  
      # Create individual arglists for all fields
      for m in range(M):
          kwarg = vardict.copy()
          kwarg["field"] = fieldstack[m]
          # now we turn the kwarg into an arglist
          args = list()
          for i, a in enumerate(names[::-1]):
              # first set default
              if i < len(func_def):
                  val = func_def[i]
              if a in kwarg:
                  val = kwarg[a]
              args.append(val)
          stackargs.append(args[::-1])
  
      p = mp.Pool(num_cpus)
      result = p.map_async(_refocus_wrapper, stackargs).get()
      p.close()
      p.terminate()
      p.join()
  
      if copy:
          data = np.zeros(fieldstack.shape, dtype=result[0].dtype)
      else:
          data = fieldstack
  
      for m in range(M):
          data[m] = result[m]
  
      return data