code: def test_mvoxel_rumba():
      # Verify form of results in multi-voxel situation.
  
      data, gtab = dsi_voxels()  # multi-voxel data
      sphere = default_sphere  # repulsion 724
  
      # Models to validate
      rumba_smf = RumbaSDModel(
          gtab, n_iter=5, recon_type="smf", n_coils=1, sphere=sphere
      )
      rumba_sos = RumbaSDModel(
          gtab, n_iter=5, recon_type="sos", n_coils=32, sphere=sphere
      )
      model_list = [rumba_smf, rumba_sos]
  
      msg = "There is overlap in clustering of b-value.*"
      for model in model_list:
          with warnings.catch_warnings():
              warnings.filterwarnings(
                  "ignore", message=msg, category=UserWarning
              )
              model_fit = model.fit(data)
  
          odf = model_fit.odf(sphere)
          f_iso = model_fit.f_iso
          f_wm = model_fit.f_wm
          f_gm = model_fit.f_gm
          f_csf = model_fit.f_csf
          combined = model_fit.combined_odf_iso
  
          # Verify prediction properties
  
          with warnings.catch_warnings():
              warnings.filterwarnings(
                  "ignore", message=msg, category=UserWarning
              )
              pred_sig_1 = model_fit.predict()
              pred_sig_2 = model_fit.predict(S0=1)
              pred_sig_3 = model_fit.predict(S0=np.ones(odf.shape[:-1]))
              pred_sig_4 = model_fit.predict(gtab=gtab)
  
          assert_equal(pred_sig_1, pred_sig_2)
          assert_equal(pred_sig_3, pred_sig_4)
          assert_equal(pred_sig_1, pred_sig_3)
          assert_equal(data.shape, pred_sig_1.shape)
          assert_equal(np.all(np.isreal(pred_sig_1)), True)
          assert_equal(np.all(pred_sig_1 > 0), True)
  
          # Verify shape, positivity, realness of results
          assert_equal(
              data.shape[:-1] + (len(sphere.vertices),), odf.shape
          )
          assert_equal(np.all(np.isreal(odf)), True)
          assert_equal(np.all(odf > 0), True)
  
          assert_equal(data.shape[:-1], f_iso.shape)
          assert_equal(np.all(np.isreal(f_iso)), True)
          assert_equal(np.all(f_iso > 0), True)
  
          # Verify properties of fODF and volume fractions
          assert_equal(f_iso, f_gm + f_csf)
          assert_equal(
              combined, odf + f_iso[..., None] / len(sphere.vertices)
          )
          assert_almost_equal(f_iso + f_wm, np.ones(f_iso.shape))
          assert_almost_equal(
              np.sum(combined, axis=3), np.ones(f_iso.shape)
          )
          assert_equal(np.sum(odf, axis=3), f_wm)
  
imports: import warnings
  import numpy
  from numpy.testing import assert_equal, assert_almost_equal, assert_array_equal, assert_allclose, assert_raises
  from numpy.testing import assert_
  from dipy.reconst.rumba import RumbaSDModel, generate_kernel
  from dipy.reconst.csdeconv import AxSymShResponse
  from dipy.data import get_fnames, dsi_voxels, default_sphere, get_sphere
  from dipy.core.gradients import gradient_table, unique_bvals_tolerance
  from dipy.core.geometry import cart2sphere
  from dipy.core.sphere_stats import angular_similarity
  from dipy.reconst.tests.test_dsi import sticks_and_ball_dummies
  from dipy.sims.voxel import sticks_and_ball, multi_tensor, single_tensor
  from dipy.direction.peaks import peak_directions
  from dipy.reconst.shm import descoteaux07_legacy_msg
label_desc: Use image node_id 5 for calling a global function with example usage: test_mvoxel_rumba() without return types