code: def _get_gather_offset(self, size):
          
  
          gather_size = np.zeros(size).astype(int)
          gather_offset = np.zeros(size).astype(int)
          num_local_subjs = np.zeros(size).astype(int)
          subject_map = {}
  
          for idx, s in enumerate(np.arange(self.n_subj)):
              cur_rank = idx % size
              gather_size[cur_rank] += self.prior_size
              subject_map[idx] = (cur_rank, num_local_subjs[cur_rank])
              num_local_subjs[cur_rank] += 1
  
          for idx in np.arange(size - 1) + 1:
              gather_offset[idx] = gather_offset[idx - 1] + gather_size[idx - 1]
  
          tuple_size = tuple(gather_size)
          tuple_offset = tuple(gather_offset)
          return tuple_size, tuple_offset, subject_map
docs: Calculate the offset for gather result from this process
  
          Parameters
          ----------
  
          size : int
              The total number of process.
  
          Returns
          -------
  
          tuple_size : tuple_int
              Number of elements to send from each process
              (one integer for each process)
  
          tuple_offset : tuple_int
              Number of elements away from the first element
              in the array at which to begin the new, segmented
              array for a process
              (one integer for each process)
  
          subject_map : dictionary
              Mapping between global subject id to local id