t3frame_to_ut3frame
===================

.. py:function:: t3toolbox.backend.ufv_conversions.t3frame_to_ut3frame(frame_data, N = None, nU = None, nD = None, rL = None, rR = None)

   .. code-block:: python

      def t3frame_to_ut3frame(
              frame_data: typ.Tuple[
                  typ.Tuple[NDArray, ...],  # up_tucker_cores,   len=d, elm_shape=C+(nUi, Ni)
                  typ.Tuple[NDArray, ...],  # down_tt_cores,     len=d, elm_shape=C+(rLi, nDi, rR(i+1))
                  typ.Tuple[NDArray, ...],  # left_tt_cores,     len=d, elm_shape=C+(rLi, nUi, rL(i+1))
                  typ.Tuple[NDArray, ...],  # right_tt_cores,    len=d, elm_shape=C+(rRi, nUi, rR(i+1))
              ],
              N:  typ.Optional[int] = None,   # padded mode dim   (default max(shape))
              nU: typ.Optional[int] = None,   # padded up rank    (default max(up_ranks))
              nD: typ.Optional[int] = None,   # padded down rank  (default max(down_ranks))
              rL: typ.Optional[int] = None,   # padded left rank  (default max(left_ranks))
              rR: typ.Optional[int] = None,   # padded right rank (default max(right_ranks))
      ) -> typ.Tuple[
          NDArray,                          # up_tucker_supercore,  (d,)+C+(nU, N)
          NDArray,                          # down_tt_supercore,    (d,)+C+(rL, nD, rR)
          NDArray,                          # left_tt_supercore,    (d,)+C+(rL, nU, rL)
          NDArray,                          # right_tt_supercore,   (d,)+C+(rR, nU, rR)
          typ.Tuple[int, ...],              # shape = (N0,...,N(d-1))
          typ.Tuple[NDArray, NDArray, NDArray, NDArray],  # (up, down, frame_left, frame_right) masks
      ]:


   Pack a ragged ``T3Frame`` core-tuple into uniform frame ``.data`` (supercores + shape + masks).

   Inverse of :py:func:`ut3frame_to_t3frame`. A *single* ragged frame has ranks shared across its ``C``
   stack, so the masks come out **uniform across the stack** (varying-rank uniform batches arise only by
   ``stack``-ing a heterogeneous tree). Pads each family to common dims (default: max over modes; pass
   ``N``/``nU``/``nD``/``rL``/``rR`` to force larger) and records the real extents as prefix masks
   (``ufv_make_frame_masks``; the real content lands in the upper-left, so the prefix masks are correct).