docs: def correct_dihedral(self, construction_table,
                           use_lookup=None):
          """Reindexe the dihedral defining atom if linear reference is used.
  
          Uses :meth:`~Cartesian.check_dihedral` to obtain the problematic
          indices.
  
          Args:
              construction_table (pd.DataFrame):
              use_lookup (bool): Use a lookup variable for
                  :meth:`~chemcoord.Cartesian.get_bonds`. The default is
                  specified in ``settings['defaults']['use_lookup']``
  
          Returns:
              pd.DataFrame: Appropiately renamed construction table.
          """
          if use_lookup is None:
              use_lookup = settings['defaults']['use_lookup']
  
          problem_index = self.check_dihedral(construction_table)
          bond_dict = self._give_val_sorted_bond_dict(use_lookup=use_lookup)
          c_table = construction_table.copy()
          for i in problem_index:
              loc_i = c_table.index.get_loc(i)
              b, a, problem_d = c_table.loc[i, ['b', 'a', 'd']]
              try:
                  c_table.loc[i, 'd'] = (bond_dict[a] - {b, a, problem_d}
                                         - set(c_table.index[loc_i:]))[0]
              except IndexError:
                  visited = set(c_table.index[loc_i:]) | {b, a, problem_d}
                  tmp_bond_dict = OrderedDict([(j, bond_dict[j] - visited)
                                               for j in bond_dict[problem_d]])
                  found = False
                  while tmp_bond_dict and not found:
                      new_tmp_bond_dict = OrderedDict()
                      for new_d in tmp_bond_dict:
                          if new_d in visited:
                              continue
                          angle = self.get_angle_degrees([b, a, new_d])[0]
                          if 5 < angle < 175:
                              found = True
                              c_table.loc[i, 'd'] = new_d
                          else:
                              visited.add(new_d)
                              for j in tmp_bond_dict[new_d]:
                                  new_tmp_bond_dict[j] = bond_dict[j] - visited
                      tmp_bond_dict = new_tmp_bond_dict
                  if not found:
                      other_atoms = c_table.index[:loc_i].difference({b, a})
                      molecule = self.get_distance_to(origin=i, sort=True,
                                                      other_atoms=other_atoms)
                      k = 0
                      while not found and k < len(molecule):
                          new_d = molecule.index[k]
                          angle = self.get_angle_degrees([b, a, new_d])[0]
                          if 5 < angle < 175:
                              found = True
                              c_table.loc[i, 'd'] = new_d
                          k = k + 1
                      if not found:
                          message = ('The atom with index {} has no possibility '
                                     'to get nonlinear reference atoms'.format)
                          raise UndefinedCoordinateSystem(message(i))
          return c_table