Пример #1
0
    public void run() {
      for (int i = start; i <= end; i++) {
        for (int j = i + 1; j < cc.getNodeNumber(); j++) {

          //					double distance = calculateEuclideanDistance(cc.getCCPositions(), dim, i,j);
          double distance = 0;
          double dummy = 0;
          for (int d = 0; d < dim; d++) {
            dummy = (cc.getCCPositions()[i][d] - cc.getCCPositions()[j][d]);
            distance += (dummy * dummy);
          }
          distance = Math.sqrt(distance);
          if (distance < FORCEnDLayoutConfig.MIN_DISTANCE) continue;
          /*
           * calculate attraction or repulsion force
           *
           * attraction:
           * 				log(d(i,j)+1) x cost(i,j) x attraction factor
           * 				---------------------------------------------
           * 	  		   	          number of nodes
           *
           * repulsion:
           * 				cost(i,j) x repulsion factor
           *             -------------------------------
           *             log(d(i,j)+1) x number of nodes
           *
           */

          if (cc.getCCEdges().getEdgeCost(i, j) > 0) {
            double force =
                (Math.log(distance + 1) * cc.getCCEdges().getEdgeCost(i, j) * attraction)
                    / distance;
            for (int d = 0; d < dim; d++) {
              double displacement = (cc.getCCPositions()[j][d] - cc.getCCPositions()[i][d]) * force;
              synchronized (allDisplacements) {
                allDisplacements[i][d] += displacement;
                allDisplacements[j][d] -= displacement;
              }
            }
          } else {
            double force =
                ((cc.getCCEdges().getEdgeCost(i, j) * repulsion) / Math.log(distance + 1))
                    / distance;
            for (int d = 0; d < dim; d++) {
              double displacement = (cc.getCCPositions()[j][d] - cc.getCCPositions()[i][d]) * force;
              synchronized (allDisplacements) {
                allDisplacements[i][d] += displacement;
                allDisplacements[j][d] -= displacement;
              }
            }
          }
        }
      }
    }
Пример #2
0
  /**
   * Calculates the displacement vector for all nodes and saves it in a 2D double array.
   *
   * @param allDisplacements The displacement values for all nodes.
   * @param cc The current ConnectedComponent object.
   * @param dim The current dimensions the layouting is run in.
   * @param param The parameters object for FORCEnD.
   * @param temperature
   */
  public static void calculateDisplacementVectors(
      double[][] allDisplacements,
      ConnectedComponent cc,
      int dim,
      FORCEnDParameters param,
      double temperature) {
    setDisplacementsToZero(allDisplacements, cc.getNodeNumber(), dim);
    double attraction = param.getAttractionFactor() / cc.getNodeNumber();
    double repulsion = param.getRepulsionFactor() / cc.getNodeNumber();
    int[] list = new int[cc.getNodeNumber()];
    if (TaskConfig.useThreads) {
      //			if(false){
      ExecutorService es =
          java.util.concurrent.Executors.newFixedThreadPool(TaskConfig.maxNoThreads);
      for (int i = 0; i < TaskConfig.maxNoThreads; i++) {
        DisplacementCalculator s =
            new DisplacementCalculator(
                attraction,
                repulsion,
                allDisplacements,
                cc,
                dim,
                list,
                (int) Math.rint((double) cc.getNodeNumber() / TaskConfig.maxNoThreads) * i,
                Math.min(
                    (int) Math.rint((double) cc.getNodeNumber() / TaskConfig.maxNoThreads) * (i + 1)
                        - 1,
                    cc.getNodeNumber() - 1));

        es.execute(s);
      }
      //			for (int i = 0; i < cc.getNodeNumber(); i++) {
      //				int start = i;
      //				int end = i;
      //				int estimatedOperation = cc.getNodeNumber()-i;
      //
      //	while(estimatedOperation<((cc.getNodeNumber()*(cc.getNodeNumber()-1))/2)/TaskConfig.maxNoThreads){
      //					if(i==cc.getNodeNumber()) break;
      //					end++;
      //					i++;
      //					estimatedOperation+=cc.getNodeNumber()-i;
      //				}
      //				DisplacementCalculator s = new
      // DisplacementCalculator(attraction,repulsion,allDisplacements,cc,dim,list,start,end);
      //				es.execute(s);
      //			}

      es.shutdown();
      try {
        es.awaitTermination(5, java.util.concurrent.TimeUnit.HOURS);
      } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
    } else {
      double distance, force, displacement;
      for (int i = 0; i < cc.getNodeNumber(); i++) {
        /*
         * only need to calculate the forces for j<i, because force(i,j) =
         * force(j,i)
         * if it should at some stage not be the case, then change
         * this!
         */

        for (int j = i + 1; j < cc.getNodeNumber(); j++) {

          distance = calculateEuclideanDistance(cc.getCCPositions(), dim, i, j);
          if (distance < FORCEnDLayoutConfig.MIN_DISTANCE) continue;
          /*
           * calculate attraction or repulsion force
           *
           * attraction:
           * 				log(d(i,j)+1) x cost(i,j) x attraction factor
           * 				---------------------------------------------
           * 	  		   	          number of nodes
           *
           * repulsion:
           * 				cost(i,j) x repulsion factor
           *             -------------------------------
           *             log(d(i,j)+1) x number of nodes
           *
           */

          if (cc.getCCEdges().getEdgeCost(i, j) > 0) {
            force =
                (Math.log(distance + 1) * cc.getCCEdges().getEdgeCost(i, j) * attraction)
                    / distance;
            for (int d = 0; d < dim; d++) {
              displacement = (cc.getCCPositions()[j][d] - cc.getCCPositions()[i][d]) * force;
              allDisplacements[i][d] += displacement;
              allDisplacements[j][d] -= displacement;
            }
          } else {
            force =
                ((cc.getCCEdges().getEdgeCost(i, j) * repulsion) / Math.log(distance + 1))
                    / distance;
            for (int d = 0; d < dim; d++) {
              displacement = (cc.getCCPositions()[j][d] - cc.getCCPositions()[i][d]) * force;
              allDisplacements[i][d] += displacement;
              allDisplacements[j][d] -= displacement;
            }
          }
        }
      }
    }

    //
  }