code: def _combine_eq_sets(eq_sets, operations):
          
          UNIT = np.eye(3)
  
          def all_equivalent_atoms_of_i(i, eq_sets, ops):
              """WORKS INPLACE on operations
              """
              visited = set([i])
              tmp_eq_sets = {j: (eq_sets[j] - visited) for j in eq_sets[i]}
  
              while tmp_eq_sets:
                  new_tmp_eq_sets = {}
                  for j in tmp_eq_sets:
                      if j in visited:
                          continue
                      visited.add(j)
                      for k in tmp_eq_sets[j]:
                          new_tmp_eq_sets[k] = eq_sets[k] - visited
                          if i not in ops[k]:
                              ops[k][i] = (np.dot(ops[j][i], ops[k][j])
                                           if k != i else UNIT)
                          ops[i][k] = ops[k][i].T
                  tmp_eq_sets = new_tmp_eq_sets
              return visited, ops
  
          eq_sets = copy.deepcopy(eq_sets)
          new_eq_sets = {}
          ops = copy.deepcopy(operations)
          to_be_deleted = set()
          for i in eq_sets:
              if i in to_be_deleted:
                  continue
              visited, ops = all_equivalent_atoms_of_i(i, eq_sets, ops)
              to_be_deleted |= visited - {i}
  
          for k in to_be_deleted:
              eq_sets.pop(k, None)
          return {'eq_sets': eq_sets,
                  'sym_ops': ops}
docs: Combines the dicts of _get_equivalent_atom_dicts into one
  
          Args:
              eq_sets (dict)
              operations (dict)
  
          Returns:
              dict: The returned dictionary has two possible keys:
  
              ``eq_sets``:
              A dictionary of indices mapping to sets of indices,
              each key maps to indices of all equivalent atoms.
              The keys are guaranteed to be not equivalent.
  
              ``sym_ops``:
              Twofold nested dictionary.
              ``operations[i][j]`` gives the symmetry operation
              that maps atom ``i`` unto ``j``.