docs: def get_kinks(self):
          """
          Finds all the kinks in mixing ratio where reaction products changes
          along the tie line of composition self.c1 and composition self.c2.
  
          Returns:
              Zip object of tuples (index, mixing ratio,
                                    reaction energy per atom in eV/atom,
                                    reaction formula,
                                    reaction energy per mol of reaction
                                    formula in kJ/mol).
          """
          c1_coord = self.pd.pd_coords(self.comp1)
          c2_coord = self.pd.pd_coords(self.comp2)
          n1 = self.comp1.num_atoms
          n2 = self.comp2.num_atoms
          critical_comp = self.pd.get_critical_compositions(self.comp1,
                                                            self.comp2)
          x_kink, energy_kink, react_kink, energy_per_rxt_formula = \
              [], [], [], []
          if all(c1_coord == c2_coord):
              x_kink = [0, 1]
              energy_kink = [self._get_energy(x) for x in x_kink]
              react_kink = [self._get_reaction(x) for x in x_kink]
              num_atoms = [(x * self.comp1.num_atoms +
                            (1-x) * self.comp2.num_atoms) for x in x_kink]
              energy_per_rxt_formula = [energy_kink[i] *
                                        self._get_elmt_amt_in_rxt(
                                            react_kink[i]) /
                                        num_atoms[i] *
                                        InterfacialReactivity.EV_TO_KJ_PER_MOL
                                        for i in range(2)]
          else:
              for i in reversed(critical_comp):
                  # Gets mixing ratio x at kinks.
                  c = self.pd.pd_coords(i)
                  x = np.linalg.norm(c - c2_coord) / \
                      np.linalg.norm(c1_coord - c2_coord)
                  # Modifies mixing ratio in case compositions self.comp1 and
                  # self.comp2 are not normalized.
                  x = x * n2 / (n1 + x * (n2 - n1))
                  n_atoms = x * self.comp1.num_atoms \
                      + (1-x) * self.comp2.num_atoms
                  # Converts mixing ratio in comp1 - comp2 tie line to that in
                  # c1 - c2 tie line.
                  x_converted = InterfacialReactivity._convert(
                      x, self.factor1, self.factor2)
                  x_kink.append(x_converted)
                  # Gets reaction energy at kinks
                  normalized_energy = self._get_energy(x)
                  energy_kink.append(normalized_energy)
                  # Gets balanced reaction at kinks
                  rxt = self._get_reaction(x)
                  react_kink.append(rxt)
                  rxt_energy = normalized_energy * \
                      self._get_elmt_amt_in_rxt(rxt) / \
                      n_atoms
                  energy_per_rxt_formula.append(
                      rxt_energy *
                      InterfacialReactivity.EV_TO_KJ_PER_MOL)
          index_kink = range(1, len(critical_comp)+1)
          return zip(index_kink, x_kink, energy_kink, react_kink,
                     energy_per_rxt_formula)