Beispiel #1
0
  /**
   * El metodo se encarga de realizar la asignación Hibrida para depósitos con capacidad limitada
   * (Algoritmo 1).
   *
   * <p>Recibe por parámetro <code>DTDepositoVRP</code> donde contiene toda la información del
   * problema a resolver.
   *
   * <p>Retorna una colección de <code>DTAsignacion</code>. Cada <code>DTAsignacion</code> contiene
   * un deposito y una colección de clientes que estan asignados al deposito.
   *
   * @param d <code>DTDepositoVRP</code> donde contiene toda la información del problema a resolver.
   * @return Devuelve una colección de <code>DTAsignacion</code>..
   */
  public Collection<DTAsignacion> asignar(DTDepositoVRP d) {

    System.out.println("Asignar capacidad");

    clientes = new ArrayList<ClienteCap2>();
    depositos = new ArrayList<Deposito>();
    enajenados = new ArrayList<Enajenado>();

    Iterator<DTNodo> it = d.getNodos().iterator();
    while (it.hasNext()) {
      DTNodo dt = it.next();
      if (dt.getEsDesposito()) {
        Deposito dep = new Deposito(dt);
        depositos.add(dep);
      }
    }

    Iterator<DTNodo> it2 = d.getNodos().iterator();
    while (it2.hasNext()) {
      DTNodo dt = it2.next();
      if (!dt.getEsDesposito()) {
        ClienteCap2 cli = new ClienteCap2(dt);
        cli.setMu(calcularMu(cli, depositos));
        clientes.add(cli);
      }
    }

    // Calculo los 2 clientes mas cercanos para cada cliente (precalculo para fase 2)
    Iterator<ClienteCap2> it3 = this.clientes.iterator();

    while (it3.hasNext()) {
      ClienteCap2 cliente = it3.next();
      cliente = addClientesMasCercanos(cliente);
      System.out.println(
          "Clientes mas cercanos"
              + cliente.getNodo().getId()
              + " y nodos "
              + cliente.getClieteMasCercano1().getNodo().getId()
              + " ,"
              + cliente.getClieteMasCercano2().getNodo().getId());
    }

    // Asigno los nodos por urgencia (fase 1).
    while (clientes.size() > 0) {
      TreeSet<ClienteCap2> tr = new TreeSet<ClienteCap2>(clientes);
      Iterator<ClienteCap2> itc = tr.iterator();
      ClienteCap2 proximo = itc.next();
      proximo
          .getMasCercano()
          .agregarCliente(proximo); // agrego el cliente en el deposito mas cercano.
      clientes.remove(proximo);
      Iterator<ClienteCap2> itcli = clientes.iterator();
      while (itcli.hasNext()) {
        ClienteCap2 n = itcli.next();
        n.setMu(calcularMu(n, depositos));
      }
    }

    // agrego a lista si los 2 cliente + cercanos a cada cliente pertencen al mismo deposito
    // deposito (que no es el mismo que el deposito asignado para el cliente).

    // acaaaa
    int capacidadvehiculo = Integer.valueOf(d.getCAPACITY());
    System.out.println("cap del vehiculo " + capacidadvehiculo);

    ArrayList<DTAsignacion> ar = null;
    int costomenor = 0;

    Iterator<Deposito> itdd = this.depositos.iterator();
    while (itdd.hasNext()) {
      Deposito dep = itdd.next();
      DTAsignacion dta = new DTAsignacion(dep.getNodo());
      Iterator<Cliente> itcli = dep.getAsignados().iterator();
      while (itcli.hasNext()) {
        Cliente cli = itcli.next();
        dta.agregarCliente(cli.getNodo());
      }
      Iterator<DTRuteo> itrut =
          Fabrica.getInstancia().getRuteo().rutear(dta, capacidadvehiculo).iterator();
      while (itrut.hasNext()) {
        DTRuteo next = itrut.next();
        costomenor = costomenor + next.getCosto();
      }
    }
    System.out.println("costo inicial " + costomenor);
    int cantidadIteraciones = 0;

    // Inicializo el Tiempo en Config
    Config.getInstancia().empezarAlgoritmo(costomenor);
    ArrayList<Integer> aux, tmp;
    tmp = new ArrayList<Integer>();
    boolean terminar = false;
    while (!terminar) {
      cantidadIteraciones++;
      System.out.println("Cantidad Iteraciones " + cantidadIteraciones);
      this.calcularEnagenamiento();
      // Aplico todos los cambios de la lista de enajenados ....

      aux = new ArrayList<Integer>();
      Iterator<Enajenado> itena = this.enajenados.iterator();
      while (itena.hasNext()) {
        Enajenado ena = itena.next();

        aux.add(ena.getCliente().getNodo().getId());

        if (ena.getDepositoDestino().getCapacidadLibrePonderada()
            >= ena.getCliente().getNodo().getDemanda()) {
          Iterator<Deposito> respita = this.depositos.iterator();
          while (respita.hasNext()) {
            Deposito dep = respita.next();
            Deposito nuevo = new Deposito(dep);
            if (nuevo.getNodo().getId() == ena.getDeposito().getNodo().getId())
              nuevo.sacarCliente(ena.getCliente());
            if (nuevo.getNodo().getId() == ena.getDepositoDestino().getNodo().getId())
              nuevo.agregarCliente(ena.getCliente());

            DTAsignacion dta = new DTAsignacion(nuevo.getNodo());
            Iterator<Cliente> itcli = nuevo.getAsignados().iterator();
            while (itcli.hasNext()) {
              Cliente cli = itcli.next();
              dta.agregarCliente(cli.getNodo());
            }
          }
          ena.getDeposito().sacarCliente(ena.getCliente());
          ena.getDepositoDestino().agregarCliente(ena.getCliente());
        }
      }

      boolean equalLists = ((aux.size() == tmp.size()) && (tmp.containsAll(aux)));
      tmp = new ArrayList<Integer>();
      tmp.addAll(aux);

      if ((Config.getInstancia().terminarPorConfig(cantidadIteraciones, costomenor)) || equalLists)
        terminar = true;
    }
    // construir DT de salida.
    ar = new ArrayList<DTAsignacion>();

    Iterator<Deposito> itd = depositos.iterator();
    while (itd.hasNext()) {
      Deposito dep = itd.next();
      DTAsignacion dta = new DTAsignacion(dep.getNodo());
      Iterator<Cliente> itcli = dep.getAsignados().iterator();
      while (itcli.hasNext()) {
        Cliente cli = itcli.next();
        dta.agregarCliente(cli.getNodo());
      }
      ar.add(dta);
    }

    Penalization.getInstancia().getCalculoPenalidad(ar);

    return ar;
  }
Beispiel #2
0
  /** Calcula los nodos que son enajendados. */
  private void calcularEnagenamiento() {
    Iterator<Deposito> itd1 = depositos.iterator();
    this.enajenados = new ArrayList<Enajenado>();
    while (itd1.hasNext()) {
      Deposito dep1 = itd1.next();
      Iterator<Cliente> itc1 = dep1.getAsignados().iterator();

      while (itc1.hasNext()) {
        Cliente clientebase = itc1.next();
        Iterator<Deposito> it4 = depositos.iterator();
        while (it4.hasNext()) {
          boolean encontre1 = false;
          boolean encontre2 = false;
          Deposito dep2 = it4.next();
          if (dep1.getNodo().getId() != dep2.getNodo().getId()) {

            Iterator<Cliente> it5 = dep2.getAsignados().iterator();
            while (it5.hasNext()) {
              Cliente cliente = it5.next();
              if (((ClienteCap2) clientebase).getClieteMasCercano1().getNodo().getId()
                  == cliente.getNodo().getId()) encontre1 = true;
              if (((ClienteCap2) clientebase).getClieteMasCercano2().getNodo().getId()
                  == cliente.getNodo().getId()) encontre2 = true;
            }
            if (encontre1 && encontre2) {
              this.enajenados.add(new Enajenado(((ClienteCap2) clientebase), dep1, dep2));
              break;
            }
          }
        }
      }
    }

    // limpio lista de enegenados por la distancia al deposito.
    int distCaC1, distCaC2, distDep;
    Iterator<Enajenado> itena = this.enajenados.iterator();
    ArrayList<Enajenado> asacar = new ArrayList<Enajenado>();
    while (itena.hasNext()) {
      Enajenado ena = itena.next();
      distCaC1 =
          Distancia.getInstancia()
              .getDistancia(
                  ena.getCliente().getClieteMasCercano1().getNodo(), ena.getCliente().getNodo());
      distCaC2 =
          Distancia.getInstancia()
              .getDistancia(
                  ena.getCliente().getClieteMasCercano2().getNodo(), ena.getCliente().getNodo());
      distDep =
          Distancia.getInstancia()
              .getDistancia(ena.getCliente().getNodo(), ena.getDeposito().getNodo());

      System.out.println(
          "Clientes mas cercanos a "
              + ena.getCliente().getNodo().getId()
              + " ( "
              + ena.getDeposito().getNodo().getId()
              + " ). c 1 y c2 "
              + ena.getCliente().getClieteMasCercano1().getNodo().getId()
              + " ,"
              + ena.getCliente().getClieteMasCercano2().getNodo().getId()
              + "("
              + ena.getDepositoDestino().getNodo().getId()
              + ")");

      if (distCaC1 + distCaC2 > distDep) asacar.add(ena); // this.enajenados.remove(ena);
      else ena.setMu(distDep - (distCaC1 + distCaC2));
    }
    Iterator<Enajenado> itsacar = asacar.iterator();
    while (itsacar.hasNext()) {
      this.enajenados.remove(itsacar.next());
    }
  }
Beispiel #3
0
  /**
   * Calcula el valor de <code>mu</code>.
   *
   * @param c Cliente.
   * @param dep Colección de depósitos.
   */
  private int calcularMu(ClienteCap2 c, Collection<Deposito> dep) {
    /*Deposito  masCercano=null;
    if(dep.size()>0)
    {
    	masCercano=dep.iterator().next();
    }
    else
    {
    	return 0;
    }
    int distanciaMasCercano=Integer.MAX_VALUE;
    Iterator<Deposito> it=dep.iterator();
    while(it.hasNext())
    {
    	Deposito n=it.next();
    	if(n.getCapacidadLibre()>=c.getNodo().getDemanda())
    	{
    		if(Distancia.getInstancia().getDistancia(n.getNodo(), c.getNodo())<distanciaMasCercano)
    		{
    			masCercano=n;
    			distanciaMasCercano=Distancia.getInstancia().getDistancia(n.getNodo(), c.getNodo());
    		}
    	}
    }

    int sumatoriaDistancias=0;
    Iterator<Deposito> it2=dep.iterator();
    while(it2.hasNext())
    {
    	Deposito n=it2.next();
    	if(n.getCapacidadLibre()>=c.getNodo().getDemanda())
    	{
    		if(n.getNodo().getId()!=masCercano.getNodo().getId())
    		{
    			sumatoriaDistancias=sumatoriaDistancias+Distancia.getInstancia().getDistancia(n.getNodo(),c.getNodo());
    		}
    	}
    }
    c.setMasCercano(masCercano);
    return sumatoriaDistancias-distanciaMasCercano;*/
    Deposito masCercano = null;

    int distanciaMasCercano = Integer.MAX_VALUE;
    Iterator<Deposito> it = dep.iterator();
    while (it.hasNext()) {
      Deposito n = it.next();
      if (n.getCapacidadLibre() >= c.getNodo().getDemanda()) {
        if (Distancia.getInstancia().getDistancia(n.getNodo(), c.getNodo()) < distanciaMasCercano) {
          masCercano = n;
          distanciaMasCercano = Distancia.getInstancia().getDistancia(n.getNodo(), c.getNodo());
        }
      }
    }

    if (masCercano != null) {
      int sumatoriaDistancias = 0;
      Iterator<Deposito> it2 = dep.iterator();
      while (it2.hasNext()) {
        Deposito n = it2.next();
        if (n.getCapacidadLibre() >= c.getNodo().getDemanda()) {
          if (n.getNodo().getId() != masCercano.getNodo().getId()) {
            sumatoriaDistancias =
                sumatoriaDistancias
                    + Distancia.getInstancia().getDistancia(n.getNodo(), c.getNodo());
          }
        }
      }
      c.setMasCercano(masCercano);
      return sumatoriaDistancias - distanciaMasCercano;
    } else {
      int distanciaMasCercano2 = Integer.MAX_VALUE;
      Iterator<Deposito> it2 = dep.iterator();
      while (it2.hasNext()) {
        Deposito n = it2.next();
        if (Distancia.getInstancia().getDistancia(n.getNodo(), c.getNodo())
            < distanciaMasCercano2) {
          masCercano = n;
          distanciaMasCercano2 = Distancia.getInstancia().getDistancia(n.getNodo(), c.getNodo());
        }
      }
      c.setMasCercano(masCercano);
      return 0;
    }
  }
Beispiel #4
0
  /** M�todo principal */
  public static void main(String[] args) {
    // faz o parsing dos argumentos da linha de comnaod
    GetOpt options = new GetOpt("Projeto3", args, "vr");
    int opt;
    while ((opt = options.nextOpt()) != -1) {
      switch (opt) {
        default:
          uso();
          break;
        case 'v':
          verbose = true;
          break;
        case 'r':
          rand = new Random(0);
          break;
      }
    }
    if (rand == null) {
      rand = new Random();
    }
    if (options.optind != args.length - 3) {
      uso();
    }
    int algoritmo = Integer.parseInt(args[options.optind + 0]);
    alambiqueN = Integer.parseInt(args[options.optind + 1]);
    int iteracoes = Integer.parseInt(args[options.optind + 2]);

    // Cria o dep�sito
    deposito = new Deposito(algoritmo);
    Thread dthread = new Thread(deposito, "Deposito");

    // Cria o fornecedor
    fornecedor = new Fornecedor(iteracoes);
    Thread fThread = new Thread(fornecedor, "Fornecedor");

    // Cria os alambiques
    alambiques = new Alambique[alambiqueN];
    alambiqueThreads = new Thread[alambiqueN];
    for (int i = 0; i < alambiqueN; i++) {
      alambiques[i] = new Alambique(i);
      alambiqueThreads[i] = new Thread(alambiques[i], "Alambique" + i);
    }

    // Inicia os threads

    dthread.setPriority(Thread.NORM_PRIORITY - 1);
    dthread.start();
    fThread.setPriority(Thread.NORM_PRIORITY - 1);
    fThread.start();
    for (Thread t : alambiqueThreads) {
      t.setPriority(Thread.NORM_PRIORITY - 1);
      t.start();
    }

    // Espera at� que todos os threads sejam encerrados
    try {
      // O thread do fornecedor se encerra quando ele completa todas as itera��es
      fThread.join();

      // Aguarda 3 segundos para dar chance a todos de terminarem o que est�o fazendo,
      // em seguida todos s�o interrompidos
      Thread.sleep(3000);

      // Mata o thread do dep�sito
      dthread.interrupt();
      dthread.join();

      // Mata os alambiques
      for (Thread t : alambiqueThreads) {
        t.interrupt();
        t.join();
      }

    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    // imprime o estado final
    out.printf("**** Programa terminando%n");

    Pedido quant;
    Pedido balanco = new Pedido();
    int produzido = 0;
    int noDeposito = 0;
    int consumido = 0;

    quant = fornecedor.getProducao();
    out.printf("Produzido %s%n", quant);

    balanco.troca(quant);
    produzido += quant.total();

    quant = deposito.getDisponivel();
    for (Cana c1 : Cana.values()) {
      int n = quant.get(c1);
      balanco.troca(c1, -n);
      noDeposito += n;
    }

    Pedido totalConsumido = new Pedido();
    int totalRequisitado = 0;
    int totalEspera = 0;
    for (int i = 0; i < alambiqueN; i++) {
      quant = alambiques[i].getConsumo();
      int requisitado = alambiques[i].requisicoesConcluidas();
      int espera = alambiques[i].tempoDeEspera();
      totalConsumido.troca(quant);
      for (Cana g : Cana.values()) {
        int n = quant.get(g);
        balanco.troca(g, -n);
        consumido += n;
      }
      out.printf("Alabique %d%n", i);
      out.printf("   Cana consumida:         %s%n", quant);
      out.printf("   Requisi��es atendidas:  %d%n", requisitado);
      out.printf("   Tempo total de espera:  %d ms%n", espera);
      if (requisitado > 0) {
        out.printf("   Tempo de espera m�dio:      %.2f ms%n", espera / (double) requisitado);
      }
      totalRequisitado += requisitado;
      totalEspera += espera;
    }
    out.printf("Balan�o (deficit) � %s%n", balanco);
    out.printf(
        "Total: produzido = %d, consumido = %d," + " restando no dep�sito = %d, l�quido = %d%n",
        produzido, consumido, noDeposito, (produzido - consumido - noDeposito));
    out.printf(
        "Requisi��es conclu�das: %d, tempo de espera m�dio %.2fms%n",
        totalRequisitado, totalEspera / (double) totalRequisitado);
  }