public List<Integer> tour_selection(int depth) {

    // selection based on utility
    List<Integer> selected = new ArrayList<Integer>();
    List<Integer> candidate = new ArrayList<Integer>();

    for (int k = 0; k < problem_.getNumberOfObjectives(); k++) {
      selected.add(
          k); // WARNING! HERE YOU HAVE TO USE THE WEIGHT PROVIDED BY QINGFU (NOT SORTED!!!!)
    }

    for (int n = problem_.getNumberOfObjectives(); n < populationSize; n++) {
      candidate.add(n); // set of unselected weights
    }
    while (selected.size() < (int) (populationSize / 5.0)) {
      // int best_idd = (int) (rnd_uni(&rnd_uni_init)*candidate.size()), i2;
      int best_idd = (int) (PseudoRandom.randDouble() * candidate.size());
      // System.out.println(best_idd);
      int i2;
      int best_sub = candidate.get(best_idd);
      int s2;
      for (int i = 1; i < depth; i++) {
        i2 = (int) (PseudoRandom.randDouble() * candidate.size());
        s2 = candidate.get(i2);
        // System.out.println("Candidate: "+i2);
        if (utility_[s2] > utility_[best_sub]) {
          best_idd = i2;
          best_sub = s2;
        }
      }
      selected.add(best_sub);
      candidate.remove(best_idd);
    }
    return selected;
  }
  @Override
  public void executeMethod() throws JMException {
    int[] permutation = new int[populationSize];
    Utils.randomPermutation(permutation, populationSize);
    List<Integer> order = tour_selection(10);

    for (int i = 0; i < order.size(); i++) {
      // int n = permutation[i]; // or int n = i;
      int n = order.get(i); // or int n = i;
      frequency_[n]++;

      int type;
      double rnd = PseudoRandom.randDouble();

      // STEP 2.1. Mating selection based on probability
      if (rnd < delta_) // if (rnd < realb)
      {
        type = 1; // neighborhood
      } else {
        type = 2; // whole population
      }
      Vector<Integer> p = new Vector<Integer>();
      matingSelection(p, n, 1, type);

      // STEP 2.2. Reproduction
      Solution[] parents = new Solution[2];

      parents[0] = population.get(p.get(0));
      parents[1] = population.get(n);

      Solution[] offSpring = (Solution[]) crossoverOperator.execute(parents, (CITO_CAITO) problem_);
      mutationOperator.execute(offSpring[0], (CITO_CAITO) problem_);
      // mutationOperator.execute(offSpring[1], problem_);
      problem_.evaluate(offSpring[0]);
      problem_.evaluateConstraints(offSpring[0]);
      // problem_.evaluate(offSpring[1]);
      // problem_.evaluateConstraints(offSpring[1]);
      evaluations++;

      // STEP 2.3. Repair. Not necessary
      // STEP 2.4. Update z_
      updateReference(offSpring[0]);
      // updateReference(offSpring[1]);

      // STEP 2.5. Update of solutions
      updateProblem(offSpring[0], n, type);
      //              updateProblem(offSpring[1], n, type);
    } // for

    gen++;
    if (gen % 30 == 0) {
      comp_utility();
    }
  }
  /**
   * @author Juanjo This method selects N solutions from a set M, where N <= M using the same method
   *     proposed by Qingfu Zhang, W. Liu, and Hui Li in the paper describing MOEA/D-DRA (CEC 09
   *     COMPTETITION) An example is giving in that paper for two objectives. If N = 100, then the
   *     best solutions attenting to the weights (0,1), (1/99,98/99), ...,(98/99,1/99), (1,0) are
   *     selected.
   *     <p>Using this method result in 101 solutions instead of 100. We will just compute 100 even
   *     distributed weights and used them. The result is the same
   *     <p>In case of more than two objectives the procedure is: 1- Select a solution at random 2-
   *     Select the solution from the population which have maximum distance to it (whithout
   *     considering the already included)
   * @param n: The number of solutions to return
   * @return A solution set containing those elements
   */
  SolutionSet finalSelection(int n) throws JMException {
    SolutionSet res = new SolutionSet(n);
    if (problem_.getNumberOfObjectives() == 2) { // subcase 1
      double[][] intern_lambda = new double[n][2];
      for (int i = 0; i < n; i++) {
        double a = 1.0 * i / (n - 1);
        intern_lambda[i][0] = a;
        intern_lambda[i][1] = 1 - a;
      } // for

      // we have now the weights, now select the best solution for each of them
      for (int i = 0; i < n; i++) {
        Solution current_best = population.get(0);
        int index = 0;
        double value = fitnessFunction(current_best, intern_lambda[i]);
        for (int j = 1; j < n; j++) {
          double aux =
              fitnessFunction(
                  population.get(j), intern_lambda[i]); // we are looking the best for the weight i
          if (aux < value) { // solution in position j is better!
            value = aux;
            current_best = population.get(j);
          }
        }
        res.add(new Solution(current_best));
      }

    } else { // general case (more than two objectives)

      Distance distance_utility = new Distance();
      int random_index = PseudoRandom.randInt(0, population.size() - 1);

      // create a list containing all the solutions but the selected one (only references to them)
      List<Solution> candidate = new LinkedList<Solution>();
      candidate.add(population.get(random_index));

      for (int i = 0; i < population.size(); i++) {
        if (i != random_index) {
          candidate.add(population.get(i));
        }
      } // for

      while (res.size() < n) {
        int index = 0;
        Solution selected = candidate.get(0); // it should be a next! (n <= population size!)
        double distance_value =
            distance_utility.distanceToSolutionSetInObjectiveSpace(selected, res);
        int i = 1;
        while (i < candidate.size()) {
          Solution next_candidate = candidate.get(i);
          double aux =
              distance_value =
                  distance_utility.distanceToSolutionSetInObjectiveSpace(next_candidate, res);
          if (aux > distance_value) {
            distance_value = aux;
            index = i;
          }
          i++;
        }

        // add the selected to res and remove from candidate list
        res.add(new Solution(candidate.remove(index)));
      } //
    }
    return res;
  }