code: def _bem_specify_coils(bem, coils, coord_frame, mults, n_jobs):
      """Set up for computing the solution at a set of MEG coils.
  
      Parameters
      ----------
      bem : instance of ConductorModel
          BEM information
      coils : list of dict, len(n_MEG_sensors)
          MEG sensor information dicts
      coord_frame : int
          Class constant identifying coordinate frame
      mults : ndarray, shape (1, n_BEM_vertices)
          Multiplier for every vertex in BEM
      %(n_jobs)s
  
      Returns
      -------
      sol: ndarray, shape (n_MEG_sensors, n_BEM_vertices)
          MEG solution
      """
      # Make sure MEG coils are in MRI coordinate frame to match BEM coords
      coils, coord_frame = _check_coil_frame(coils, coord_frame, bem)
  
      # leaving this in in case we want to easily add in the future
      # if method != 'simple':  # in ['ferguson', 'urankar']:
      #     raise NotImplementedError
  
      # Compute the weighting factors to obtain the magnetic field in the linear
      # potential approximation
  
      # Process each of the surfaces
      rmags, cosmags, ws, bins = _triage_coils(coils)
      del coils
      lens = np.cumsum(np.r_[0, [len(s["rr"]) for s in bem["surfs"]]])
      sol = np.zeros((bins[-1] + 1, bem["solution"].shape[1]))
  
      lims = np.concatenate(
          [np.arange(0, sol.shape[0], 100), [sol.shape[0]]]
      )
      # Put through the bem (in channel-based chunks to save memory)
      for start, stop in zip(lims[:-1], lims[1:]):
          mask = np.logical_and(bins >= start, bins < stop)
          r, c, w, b = (
              rmags[mask],
              cosmags[mask],
              ws[mask],
              bins[mask] - start,
          )
          # Compute coeffs for each surface, one at a time
          for o1, o2, surf, mult in zip(
              lens[:-1], lens[1:], bem["surfs"], bem["field_mult"]
          ):
              coeff = _lin_field_coeff(surf, mult, r, c, w, b, n_jobs)
              sol[start:stop] += np.dot(coeff, bem["solution"][o1:o2])
      sol *= mults
      return sol
  
imports: from copy import deepcopy
  import numpy
  from .._fiff.constants import FIFF
  from ..bem import _import_openmeeg, _make_openmeeg_geometry
  from ..fixes import bincount, jit
  from ..parallel import parallel_func
  from ..surface import _jit_cross, _project_onto_surface
  from ..transforms import apply_trans, invert_transform
  from ..utils import _check_option, _pl, fill_doc, logger, verbose, warn
label_desc: Use image node_id 6 for calling a global function with example usage: _bem_specify_coils(bem, coils, coord_frame, mults, n_jobs) and returns: sol