code: def shore_indices(radial_order, index):
      r"""Given the basis order and the index, return the shore indices n, l, m
      for modified Merlet's 3D-SHORE
      ..math::
              :nowrap:
                  \begin{equation}
                      \textbf{E}(q\textbf{u})=\sum_{l=0, even}^{N_{max}}
                                              \sum_{n=l}^{(N_{max}+l)/2}
                                              \sum_{m=-l}^l c_{nlm}
                                              \phi_{nlm}(q\textbf{u})
                  \end{equation}
  
      where $\phi_{nlm}$ is
      ..math::
              :nowrap:
                  \begin{equation}
                      \phi_{nlm}^{SHORE}(q\textbf{u})=\Biggl[\dfrac{2(n-l)!}
                          {\zeta^{3/2} \Gamma(n+3/2)} \Biggr]^{1/2}
                          \Biggl(\dfrac{q^2}{\zeta}\Biggr)^{l/2}
                          exp\Biggl(\dfrac{-q^2}{2\zeta}\Biggr)
                          L^{l+1/2}_{n-l} \Biggl(\dfrac{q^2}{\zeta}\Biggr)
                          Y_l^m(\textbf{u}).
                  \end{equation}
  
      Parameters
      ----------
      radial_order : unsigned int
          an even integer that represent the maximal order of the basis
      index : unsigned int
          index of the coefficients, start from 0
  
      Returns
      -------
      n :  unsigned int
          the index n of the modified shore basis
      l :  unsigned int
          the index l of the modified shore basis
      m :  unsigned int
          the index m of the modified shore basis
      """
  
      F = radial_order / 2
      n_c = np.round(1 / 6.0 * (F + 1) * (F + 2) * (4 * F + 3))
      n_i = 0
      l_i = 0
      m_i = 0
  
      if n_c < (index + 1):
          msg = "The index %s is higher than the number of" % index
          msg += " coefficients of the truncated basis,"
          msg += " which is %s starting from 0." % int(n_c - 1)
          msg += " Select a lower index."
          raise ValueError(msg)
      else:
          counter = 0
          for l in range(0, radial_order + 1, 2):
              for n in range(l, int((radial_order + l) / 2) + 1):
                  for m in range(-l, l + 1):
                      if counter == index:
                          n_i = n
                          l_i = l
                          m_i = m
                      counter += 1
      return n_i, l_i, m_i
  
imports: from warnings import warn
  from math import factorial
  import numpy
  from scipy.special import genlaguerre, gamma, hyp2f1
  from dipy.reconst.cache import Cache
  from dipy.reconst.multi_voxel import multi_voxel_fit
  from dipy.reconst.shm import real_sh_descoteaux_from_index
  from dipy.core.geometry import cart2sphere
  from dipy.utils.optpkg import optional_package
label_desc: Use image node_id 10 for calling a global function with example usage: shore_indices(radial_order, index) and returns: n_i,  l_i,  m_i