Erreur introuvable :/

Bonsoir , jai toujours cette erreur:
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 7
[java] at jadex.examples.cleanerworld.multi.testenvironment.ga.ModifiedNSGAII.execute(Unknown Source)



le souci que jarrive pas de tt a localisé l'erreur depuis 3 jours , qui peut maider?
voiçi ma classe:
//=================================================================================================================
// My adapted version of cleaner agent
// (Modified version of r-NSGAII)
//=================================================================================================================

package jadex.examples.cleanerworld.multi.testenvironment.ga;


import jadex.examples.cleanerworld.multi.Obstacle;
import jadex.examples.cleanerworld.multi.TestCase;
import jadex.examples.cleanerworld.multi.Waste;
import jadex.examples.cleanerworld.multi.testenvironment.export.TestCase2XML;
import jadex.examples.cleanerworld.multi.utils.CommonUtil;
import jadex.examples.cleanerworld.multi.mocks.MockWasteObsRealProblem;
import jadex.examples.cleanerworld.multi.testenvironment.ga.rdominance;
import jadex.examples.cleanerworld.multi.testenvironment.ga.RefPoint;

import java.io.File;

import jmetal.base.*;
import jmetal.util.*;


public class ModifiedNSGAII extends Algorithm {


private Problem problem_;

public ModifiedNSGAII(Problem problem){
this.problem_ = problem;
} // NSGAII



public SolutionSet execute() throws JMException {
int populationSize ;
int maxEvaluations ;
int evaluations ;
int numWaste =4;
int numObstacles =4;
double dmin = 0,dmax = 0;
double [][]chromosomes = new double[1000][1000];
double fmin[]=new double[7];//7 is the number of obj
double fmax[]= new double [7];
double fit0[]= new double[1000];
double fit1[]= new double[1000];
double fit2[]= new double[1000];
double fit3[]= new double[1000];
double fit4[]= new double[1000];
double fit5[]= new double[1000];
double fit6[]= new double[1000];
double sigma= 1;
double sigma_2 = 1;
int m=0;
int w=0;
// les c

SolutionSet population ;
SolutionSet offspringPopulation ;
SolutionSet union ;

Operator mutationOperator ;
Operator crossoverOperator ;
Operator selectionOperator ;

Distance distance = new Distance() ;

//======================
//Read the parameters
//======================
populationSize = ((Integer)this.getInputParameter("populationSize")).intValue();
maxEvaluations = ((Integer)this.getInputParameter("maxEvaluations")).intValue();

//======================
//Initialize the variables
//======================
population = new SolutionSet(populationSize);
evaluations = 0;
RefPoint R = new RefPoint(0.5,0.6);
//======================
//Read the operators
//======================
mutationOperator = this.operators_.get("mutation");
crossoverOperator = this.operators_.get("crossover");
selectionOperator = this.operators_.get("selection");

//=====================================================
//1--Create the initial solutionSet and assign fitness
//======================================================
Solution newSolution;
MockWasteObsRealProblem problem_ = new MockWasteObsRealProblem(numWaste, numObstacles);
String pathPrefix = CommonUtil.getProjectPath() + File.separatorChar + "inputs" + File.separatorChar;
int d1=0;

for (int i = 0; i < populationSize; i++) {

newSolution = new Solution(problem_);
String fullPath = pathPrefix + "tc" + String.valueOf(i+1) + ".xml";
loadPredefiedTestCase(newSolution, fullPath);
problem_.evaluate(newSolution);
problem_.evaluateConstraints(newSolution);
for(int i2=0;i2<=((numWaste+numObstacles)*2+6);i2++)
{
chromosomes[d1][i2]=problem_.getchromosome(d1,i2);
}
d1++;
evaluations++;
// System.out.println("============evaluations n° = "+ evaluations+"========================");
population.add(newSolution);
} //for

//*******************************************************************
// -- Start the evolution process --
//********************************************************************

// Generations ...
while (evaluations < maxEvaluations) { //Begin while
w++;
System.out.println("==========================generation=================="+w);
offspringPopulation = new SolutionSet(populationSize);
Solution [] parents = new Solution[2];
for (int i = 0; i < (populationSize/2); i++){
System.out.println("i dans la generation = "+i);

//=================================
//2 - Select parents for reproduction
//===================================
parents[0] = (Solution)selectionOperator.execute(population);
parents[1] = (Solution)selectionOperator.execute(population);

if (evaluations < maxEvaluations) { //We add offSprings to offSpringPopulation
//=================================================
//3 - Perform crossover and mutation to obtain offspring
//==================================================

Solution [] offSpring = (Solution []) crossoverOperator.execute(parents);
mutationOperator.execute(offSpring[0]);
mutationOperator.execute(offSpring[1]);
problem_.evaluate(offSpring[0]);
problem_.evaluateConstraints(offSpring[0]);
problem_.evaluate(offSpring[1]);
problem_.evaluateConstraints(offSpring[1]);
//================================================
//3+1 -Add offspring to offspringpopulation
//================================================
offspringPopulation.add(offSpring[0]);

for(int i2=0;i2<=((numWaste+numObstacles)*2+6);i2++)
{
chromosomes[d1][i2]=problem_.getchromosome(d1,i2);
}
d1++;

offspringPopulation.add(offSpring[1]);
for(int i2=0;i2<=((numWaste+numObstacles)*2+6);i2++)
{
chromosomes[d1][i2]=problem_.getchromosome(d1,i2);
}
d1++;
evaluations += 2;
// System.out.println("============evaluations = "+ evaluations+"========================");

}
else { //We add Parents to offSpringPopulation
//================================================
//3+2 -Add offspring to offspringpopulation
//================================================
offspringPopulation.add(new Solution(parents[0]));
for(int i2=0;i2<=((numWaste+numObstacles)*2+6);i2++)
{
chromosomes[d1][i2]=problem_.getchromosome(d1,i2);
}
d1++;
offspringPopulation.add(new Solution(parents[1]));
for(int i2=0;i2<=((numWaste+numObstacles)*2+6);i2++)
{
chromosomes[d1][i2]=problem_.getchromosome(d1,i2);
}
d1++;
} // if
} // for


//=================================================================
//4 -- Create the solutionSet Union = Initial solutionSet + offSpring
//=================================================================
union = ((SolutionSet)population).union(offspringPopulation);

System.out.println("affichage de l'union de taille = "+union.size());
for(int i=0;i<union.size();i++)
{
for(int j=(((numWaste+numObstacles)*2));j<=(((numWaste+numObstacles)*2)+6);j++)
{
System.out.print(chromosomes[i][j]+ "\t");
}
System.out.println("\n");
}

//==============================================================================
//5 -- Compute the fmin and fmax for each objective functions of the Union SolutionSet
//==============================================================================
for(int i=0;i< (union.size());i++)
{
fit0[i]=problem_.getf0(i);
fit1[i]=problem_.getf1(i);
fit2[i]=problem_.getf2(i);
fit3[i]=problem_.getf3(i);
fit4[i]=problem_.getf4(i);
fit5[i]=problem_.getf5(i);
fit6[i]=problem_.getf6(i);

}
System.out.println("affichage de fit0");


System.out.println("\n");
fmin[m]=fit0[0];
fmax[m]=fit0[0];
//f0//
for(int i=0;i<=(union.size()-2);i++)
{
if(fit0[i+1]<fmin[m])
{
fmin[m]=fit0[i+1];
}
if(fit0[i+1]> fmax[m])
{
fmax[m]=fit0[i+1];
}
}

m++;
//f1//
fmin[m]=fit1[0];
fmax[m]=fit1[0];
for(int i=0;i<=(union.size()-2);i++)
{
if(fit1[i+1]<fmin[m])
{
fmin[m]=fit1[i+1];
}
if(fit1[i+1]> fmax[m])
{
fmax[m]=fit1[i+1];
}
}

m++;
//f2//
fmin[m]=fit2[0];
fmax[m]=fit2[0];
for(int i=0;i<=(union.size()-2);i++)
{
if(fit2[i+1]<fmin[m])
{
fmin[m]=fit2[i+1];
}
if(fit2[i+1]> fmax[m])
{
fmax[m]=fit2[i+1];
}
}

m++;
//f3//
fmin[m]=fit3[0];
fmax[m]=fit3[0];
for(int i=0;i<=(union.size()-2);i++)
{
if(fit3[i+1]<fmin[m])
{
fmin[m]=fit3[i+1];
}
if(fit3[i+1]> fmax[m])
{
fmax[m]=fit3[i+1];
}
}

m++;
//f4//
fmin[m]=fit4[0];
fmax[m]=fit4[0];
for(int i=0;i<=(union.size()-2);i++)
{
if(fit4[i+1]<fmin[m])
{
fmin[m]=fit4[i+1];
}
if(fit4[i+1]> fmax[m])
{
fmax[m]=fit4[i+1];
}
}

m++;
//f5//
fmin[m]=fit5[0];
fmax[m]=fit5[0];
for(int i=0;i<=(union.size()-2);i++)
{
if(fit5[i+1]<fmin[0])
{
fmin[m]=fit5[i+1];
}
if(fit5[i+1]> fmax[m])
{
fmax[m]=fit5[i+1];
}
}

m++;
//f6//
fmin[m]=fit6[0];
fmax[m]=fit6[0];
for(int i=0;i<=(union.size()-2);i++)
{
if(fit6[i+1]<fmin[m])
{
fmin[m]=fit6[i+1];
}
if(fit6[i+1]> fmax[m])
{
fmax[m]=fit6[i+1];
}
}

//=============================================================================================
//6 -- Sort based on r_dominance
//=============================================================================================


sigma_2= sigma_2 - ((1-sigma)/w);
System.out.println("sigma_2 = "+sigma_2);

//============================================================================
// 6-1 Compute the distance to reference assignement(X) for the union SolutionSet
//=============================================================================

int SizeUnion = union.size();
distance_to_reference_assignement(numWaste,numObstacles,chromosomes,7,SizeUnion,fmin,fmax,R);
/*System.out.println("affichage de t aprés le calcul de distance de references = ");
for(int i=0;i<union.size();i++)
{
for(int j=0;j<=((numWaste+numObstacles)*2+7);j++)
{
System.out.print(chromosomes[i][j]+ "\t");
}
System.out.println("\n");
}*/
/*Compute the min and max of X**/
dmin= chromosomes[0][(numWaste+numObstacles)*2+7];
dmax=chromosomes[0][(numWaste+numObstacles)*2+7];
for(int i=0;i<=(union.size()-2);i++)
{
if(chromosomes[i+1][(numWaste+numObstacles)*2+7] < dmin)
{
dmin=chromosomes[i+1][(numWaste+numObstacles)*2+7];
}
if(chromosomes[i+1][(numWaste+numObstacles)*2+7] > dmax)
{
dmax=chromosomes[i+1][(numWaste+numObstacles)*2+7];
}
}

System.out.println("dmin = "+dmin);
System.out.println("dmax = "+dmax);
//======================================================
//6-2 non_domination_sort_mod of the Union SolutionSet
//=======================================================

rdominance ranking = new rdominance(union,chromosomes,dmin,dmax,numWaste,numObstacles,sigma_2);

int remain = populationSize;
int index = 0;
SolutionSet front = null;
population.clear();


/* System.out.println("affichage de l'union avec le rank =");
for(int i=0;i<union.size();i++)
{
for(int j=0;j<=((numWaste +numObstacles)*2+8);j++)
{
System.out.print(chromosomes[i][j]+ "\t");
}
System.out.println("\n");
}*/

// Obtain the next front
front = ranking.getSubfront(index);

while ((remain > 0) && (remain >= front.size())){
//Assign crowding distance to individuals
distance.crowdingDistanceAssignment(front, problem_.getNumberOfObjectives());
//Add the individuals of this front
for (int k = 0; k < front.size(); k++ ) {
population.add(front.get(k));
} // for

//Decrement remain
remain = remain - front.size();

//Obtain the next front
index++;
if (remain > 0) {
front = ranking.getSubfront(index);
} // if
// y++;
} // while

// remain is less than front(index).size, insert only the best one
if (remain > 0) { // front contains individuals to insert
distance.crowdingDistanceAssignment(front,problem_.getNumberOfObjectives());
front.sort(new jmetal.base.operator.comparator.CrowdingComparator());
for (int k = 0; k < remain; k++) {
population.add(front.get(k));
} // for

remain = 0;
} // if
} // while

// Return the first non-dominated front
rdominance ranking = new rdominance(population,chromosomes,dmin,dmax,numWaste,numObstacles,sigma_2);
return ranking.getSubfront(0);
} // execute


//*************************************************************************************************************
// Load predefined a test case from xml file
//**************************************************************************************************************
private void loadPredefiedTestCase(Solution s, String fileFullPath) {
File f = new File(fileFullPath);
if (f.exists()) {
TestCase tc = TestCase2XML.load(fileFullPath);

DecisionVariables decisionVariables = s.getDecisionVariables();
int mid = decisionVariables.size() / 2;
int numObstacles = tc.getObstacles().length;
int numWaste = tc.getWastes().length;

if (numObstacles + numWaste != mid) {
CommonUtil.print("ModifiedNSGAII: the numbers of obstacle and waste are not compatible!");
} else {
try {
for (int i = 0; i < numObstacles; i++) {
Obstacle obs = tc.getObstacle(i);
decisionVariables.variables_[i].setValue(obs.getLocation().getX());
decisionVariables.variables_[i+mid].setValue(obs.getLocation().getY());

}

for (int i = 0; i < numWaste; i++) {
Waste w = tc.getWaste(i);
decisionVariables.variables_[numObstacles + i].setValue(w.getLocation().getX());
decisionVariables.variables_[numObstacles + i +mid].setValue(w.getLocation().getY());
}

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

} else {
CommonUtil.print("ModifiedNSGAII: file " + fileFullPath + " does not exist!");
}
}
//*************************************************************************************************************
// Distance_to_reference_assignement function
//*************************************************************************************************************
public static double distance_to_reference_assignement(int numWaste,int numObstacles,double[][] chromosomes,int M,int SizeUnion,double[] fmin,double[] fmax,RefPoint R)
{
double x = 0;
for(int j=0;j<SizeUnion;j++)
{
//System.out.println("j = "+j);
double result;
double sum = 0;

for (int i1=0;i1<M;i1++)
{
//System.out.println("M = "+i1);
if(i1 % 2 == 0)
{

double B= carre((chromosomes[j][((numWaste+numObstacles)*2)+i1] - R.x) / (fmax[i1]-fmin[i1]));
sum= sum +floor(B/7,4);


}else{

double B= carre((chromosomes[j][((numWaste+numObstacles)*2)+i1] - R.y) / (fmax[i1]-fmin[i1]));
sum = sum + floor(B/7,4);

}
}


result=Math.sqrt(sum);
x=floor(result,4);
chromosomes[j][((numWaste+numObstacles)*2)+7]=x;


}
return x;
}
//===============================================================
public static double floor(double a, int n) {
double p = Math.pow(10.0, n);
return Math.floor((a*p)+0.5) / p;
}
//=========================================================

public static double carre(double x)
{
double y = x * x;
return y;
}

} // NSGA-II


//===========================================================================================================
//By Sabrine Kalboussi,Master student,ISG of Tunis
//===========================================================================================================