UQPyL 2.0.9__tar.gz → 2.0.11__tar.gz

{UQPyL-2.0.9 → UQPyL-2.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: UQPyL
-Version: 2.0.9
+Version: 2.0.11
 Summary: A python package for parameter uncertainty quantification and optimization
 Author: wmtSky
 Author-email: wmtSky <wmtsky@hhu.edu.cn>
@@ -53,7 +53,7 @@ License-File: LICENSE.md
 
 (* indicates solving computational expensive optimization problem)
 - **Single Objective Optimization**: SCE-UA, ML-SCE-UA, GA, CSA, PSO, DE, ABC, ASMO*, EGO*
-- **Multi-Objective Optimization**: MOEA/D, NSGA-II, RVEA, MOASMO*
+- **Multi-Objective Optimization**: MOEA/D, NSGA-II, RVEA, NSGA-III, MOASMO*
 
 *Note: The library is still being updated. If you need other algorithms, please contact us.*
 

{UQPyL-2.0.9 → UQPyL-2.0.11}/README.md

@@ -36,7 +36,7 @@
 
 (* indicates solving computational expensive optimization problem)
 - **Single Objective Optimization**: SCE-UA, ML-SCE-UA, GA, CSA, PSO, DE, ABC, ASMO*, EGO*
-- **Multi-Objective Optimization**: MOEA/D, NSGA-II, RVEA, MOASMO*
+- **Multi-Objective Optimization**: MOEA/D, NSGA-II, RVEA, NSGA-III, MOASMO*
 
 *Note: The library is still being updated. If you need other algorithms, please contact us.*
 

{UQPyL-2.0.9 → UQPyL-2.0.11}/UQPyL/DoE/samplerABC.py

@@ -7,13 +7,16 @@ def decoratorRescale(func):
     def wrapper(self, *args, **kwargs):
         result=func(self, *args, **kwargs)
         
-        for arg in args:
-            if isinstance(arg, Problem):
-                return arg._unit_X_transform_to_bound(result)
+        if len(args)>=3:
+            
+            problem=args[2]
+            return problem._unit_X_transform_to_bound(result)
         
-        for key, value in kwargs.items():
-            if isinstance(value, Problem):
-                return value._unit_X_transform_to_bound(result)
+        if 'problem' in kwargs:
+            problem=kwargs['problem']
+            
+            if problem:
+                return problem._unit_X_transform_to_bound(result)
 
         return result
     return wrapper

{UQPyL-2.0.9 → UQPyL-2.0.11}/UQPyL/__init__.py

@@ -1,6 +1,6 @@
 from . import problems, surrogates, optimization, sensibility, DoE, utility
 
-__version__ = "2.0.9"
+__version__ = "2.0.11"
 __author__ = "wmtSky"
 
 __all__=[

UQPyL-2.0.11/UQPyL/optimization/__init__.py

@@ -0,0 +1,5 @@
+from .single_objective import GA, PSO, CSA, DE, SCE_UA, ML_SCE_UA, ASMO, ABC, EGO
+from .multi_objective import NSGAII, MOEAD, MOASMO, RVEA
+# from .mathematics import Boxmin, Adam
+from .algorithmABC import Algorithm
+from .population import Population

{UQPyL-2.0.9 → UQPyL-2.0.11}/UQPyL/optimization/algorithmABC.py

@@ -1,4 +1,3 @@
-import numpy as np
 import abc
 import functools
 
@@ -31,10 +30,13 @@ class Algorithm(metaclass=abc.ABCMeta):
     def initialize(self, nInit):
         
         lhs=LHS('classic')
-        xInit=lhs.sample(nInit, self.problem.nInput, problem=self.problem)
+        xInit=lhs.sample(nInit, self.problem.nInput)
+        xInit=self.problem._unit_X_transform_to_bound(xInit, dst=False)
+        
         pop=Population(xInit)
-        self.evaluate(pop); 
-            
+        
+        self.evaluate(pop)
+        
         return pop
     
     @staticmethod
@@ -54,26 +56,31 @@ class Algorithm(metaclass=abc.ABCMeta):
     def evaluate(self, pop):
         
         pop.evaluate(self.problem)
+        
         self.FEs+=pop.nPop
     
     def checkTermination(self):
         
-        if Verbose.isStop: #TODO
-            
-            return False
-        
         if self.FEs<self.maxFEs:
-            if self.maxIter is None or self.iters<self.maxIter:
+            if self.maxIter is None or self.iters<=self.maxIter:
                 if self.maxTolerateTimes is None or self.tolerateTimes<=self.maxTolerateTimes:
+                    
+                    if hasattr(self.problem, 'GUI'):
+                        self.problem.iterEmit.send()
+                        if self.problem.isStop==True:
+                            return False
+                        
                     self.iters+=1
                     return True
                 
         return False
     
     def setProblem(self, problem):
+        
         self.problem=problem
     
     def saveResult(self):
+        
         if self.problem.nOutput>1:
             self.result.save(type=1)
         else:
@@ -83,9 +90,9 @@ class Algorithm(metaclass=abc.ABCMeta):
     def record(self, pop):
         
         if self.problem.nOutput==1:
-            self.result.update(pop, self.FEs, self.iters)
+            self.result.update(pop, self.problem, self.FEs, self.iters, 'EA')
         else:
-            self.result.update(pop, self.FEs, self.iters, 1)
+            self.result.update(pop, self.problem, self.FEs, self.iters, 'MOEA')
             
     def setParameters(self, key, value):
         

UQPyL-2.0.11/UQPyL/optimization/mathematics/__init__.py

@@ -0,0 +1,2 @@
+# from .adam import Adam
+# from .boxmin import Boxmin

{UQPyL-2.0.9 → UQPyL-2.0.11}/UQPyL/optimization/metric/gd.py

@@ -5,8 +5,8 @@ def GD(pop, optimum):
     
     distances = cdist(pop, optimum, metric='euclidean')
     
-    minDist=np.min(distances, axis=1)
+    minDist = np.min(distances, axis=1)
     
-    gd=np.mean(minDist)
+    gd = np.mean(minDist)
     
     return gd

{UQPyL-2.0.9 → UQPyL-2.0.11}/UQPyL/optimization/metric/hv.py

@@ -2,14 +2,14 @@ import numpy as np
 
 def HV(pop, refPoint=None):
     
-    popObjs=pop.getBest().objs
-    _, m=popObjs.shape
+    popObjs = pop.getBest().objs
+    _, m = popObjs.shape
     
     if refPoint is None:
         
         refPoint = np.ones(m)
-        fmin=np.min(np.vstack((popObjs, np.zeros((1,m)))), axis=0)
-        fmax=np.max(np.vstack((popObjs, np.ones((1,m)))), axis=0)
+        fmin = np.min(np.vstack((popObjs, np.zeros((1,m)))), axis=0)
+        fmax = np.max(np.vstack((popObjs, np.ones((1,m)))), axis=0)
         popObjs = (popObjs - fmin)/(fmax - fmin)/1.1
         
     if m < 4:    
@@ -27,6 +27,7 @@ def HV(pop, refPoint=None):
             S=S_
         
         hyperVolume=0
+        
         for i in range(len(S)):
             p = S[i][1][0]
             hyperVolume += S[i][0] * np.abs(p[m-1] - refPoint[m-1])
@@ -37,11 +38,11 @@ def HV(pop, refPoint=None):
          
          totalHyperVolume = np.prod(upperBounds - lowerBounds)
          
-         nSamples=1e6
+         nSamples = 1e6
          
-         samples=np.random.uniform(lowerBounds, upperBounds, (int(nSamples), m))
+         samples = np.random.uniform(lowerBounds, upperBounds, (int(nSamples), m))
          
-         count=0
+         count = 0
          
          for sample in samples:
              if np.any(np.all(popObjs<=sample, axis=1)):

UQPyL-2.0.11/UQPyL/optimization/metric/igd.py

@@ -0,0 +1,14 @@
+import numpy as np
+from scipy.spatial.distance import cdist
+
+def IGD(pop, optimum):
+    
+    popObjs = pop.getBest().objs
+    
+    distances = cdist(optimum, popObjs, metric='euclidean')
+    
+    minDist = np.min(distances, axis=1)
+    
+    igd = np.mean(minDist)
+    
+    return igd

{UQPyL-2.0.9 → UQPyL-2.0.11}/UQPyL/optimization/multi_objective/__init__.py

@@ -3,3 +3,4 @@ from .nsga_ii import NSGAII
 from .moea_d import MOEAD
 from .moasmo import MOASMO
 from .rvea import RVEA
+from .nsga_iii import NSGAIII

UQPyL-2.0.11/UQPyL/optimization/multi_objective/moasmo.py

@@ -0,0 +1,185 @@
+### Multi-Objective Adaptive Surrogate Modelling-based Optimization
+import numpy as np
+from scipy.spatial.distance import cdist
+
+from ...DoE import LHS
+from ..utility_functions import NDSort
+from ...problems import PracticalProblem
+from ...surrogates import Mo_Surrogates
+from ..algorithmABC import Algorithm, Population, Verbose
+from .nsga_ii import NSGAII
+from ...surrogates.rbf.radial_basis_function import RBF
+
+class MOASMO(Algorithm):
+    '''
+    Multi-Objective Adaptive Surrogate Modelling-based Optimization <Multi-objective> <Surrogate>
+    -----------------------------------------------------------------
+    Attributes:
+        problem: Problem
+        the problem you want to solve, including the following attributes:
+            n_input: int
+                the input number of the problem
+            ub: 1d-np.ndarray or float
+                the upper bound of the problem
+            lb: 1d-np.ndarray or float
+                the lower bound of the problem
+            evaluate: Callable
+                the function to evaluate the input
+        surrogates: Surrogates
+            the surrogates you want to use, you should implement Mo_Surrogate class
+        Pct: float, default=0.2
+            the percentage of the population to be selected for infilling
+        n_init: int, default=50
+            the number of initial samples
+        n_pop: int, default=100
+            the number of population for evolution optimizer
+        maxFEs: int, default=1000
+            the maximum number of function evaluations
+        maxIter: int, default=100
+            the maximum number of iterations
+        x_init: 2d-np.ndarray, default=None
+            the initial input samples
+        y_init: 2d-np.ndarray, default=None
+            the initial output samples
+        advance_infilling: bool, default=False
+            the switch to use advanced infilling or not
+            
+    Methods:
+        run()
+            run the optimization
+    
+    References:
+        [1] W. Gong et al., Multiobjective adaptive surrogate modeling-based optimization for parameter estimation of large, complex geophysical models, 
+                            Water Resour. Res., vol. 52, no. 3, pp. 1984–2008, Mar. 2016, doi: 10.1002/2015WR018230.
+    '''
+    
+    name="MOASMO"
+    type="MOEA"
+    
+    def __init__(self, surrogates: Mo_Surrogates=None,
+                 optimizer: Algorithm=None,
+                 pct: float=0.2, nInit: int=50, nPop: int=50, 
+                 advance_infilling=False,
+                 maxFEs: int=1000, 
+                 maxIterTimes: int=100,
+                 maxTolerateTimes=None, tolerate=1e-6,
+                 verbose=True, verboseFreq=1, logFlag=True, saveFlag=False):
+
+        super().__init__(maxFEs, maxIterTimes, maxTolerateTimes, tolerate, verbose, verboseFreq, logFlag, saveFlag)
+        
+        self.setParameters('pct', pct)
+        self.setParameters('nInit', nInit)
+        self.setParameters('advance_infilling', advance_infilling)
+        
+        if surrogates is not None:
+            self.surrogates = surrogates
+        else:
+            self.surrogates = Mo_Surrogates(n_surrogates=3, models_list=[RBF(), RBF(), RBF()])
+        
+        if optimizer is not None:
+            self.optimizer = optimizer
+        else:
+            self.optimizer = NSGAII(maxFEs=10000, verbose=False, saveFlag=False, logFlag=False)
+        
+    @Verbose.decoratorRun
+    @Algorithm.initializeRun
+    def run(self, problem, xInit=None, yInit=None):
+        
+        pct = self.getParaValue('pct')
+        nInit = self.getParaValue('nInit')
+        advance_infilling = self.getParaValue('advance_infilling')
+        
+        nInfilling = int(pct*nInit)
+        
+        self.FEs=0; self.iters=0; self.tolerateTimes=0
+        
+        #Problem
+        self.problem = problem
+        
+        #SubProblem
+        subProblem = PracticalProblem(self.surrogates.predict, problem.nInput, problem.nOutput, problem.ub, problem.lb, problem.var_type, problem.var_set)
+        
+        #Termination Condition Setting
+        self.FEs = 0; self.iters = 0; self.tolerateTimes =0
+        
+        #Population Generation
+        if xInit is not None:
+            if yInit is not None:
+                pop = Population(xInit, yInit)
+            else:
+                pop = Population(xInit)
+                self.evaluate(pop)
+            
+            if nInit > len(pop):
+                pop.merge(self.initialize(nInit-len(pop)))
+            
+        else: 
+            pop = self.initialize(nInit)
+        
+        while self.checkTermination():
+            
+            #Build surrogate models
+            self.surrogates.fit(pop.decs, pop.objs)
+            
+            #Run optimization
+            res = self.optimizer.run(subProblem)
+            
+            offSpring = Population(decs=res.bestDec, objs=res.bestObj)
+            
+            if advance_infilling==False:
+                
+                if offSpring.nPop > nInfilling:
+                    bestOff = offSpring.getBest(nInfilling)
+                else:
+                    bestOff = offSpring
+                    
+            else:
+                
+                if offSpring.nPop > nInfilling:
+                    Known_FrontNo, _ = NDSort(pop)
+                    Unknown_FrontNo, _ = NDSort(offSpring)
+                    
+                    Known_best_Y = pop.objs[np.where(Known_FrontNo==1)]
+                    Unknown_best_Y = offSpring.objs[np.where(Unknown_FrontNo==1)]
+                    Unknown_best_X = offSpring.decs[np.where(Unknown_FrontNo==1)]
+                    
+                    added_points_Y = []
+                    added_points_X = []
+                    
+                    for _ in range(nInfilling):
+                        
+                        if len(added_points_Y)==0:
+                            distances = cdist(Unknown_best_Y, Known_best_Y)
+                        else:
+                            distances = cdist(Unknown_best_Y, np.append(Known_best_Y, added_points_Y, axis=0))
+
+                        max_distance_index = np.argmax(np.min(distances, axis=1))
+                        
+                        added_point = Unknown_best_Y[max_distance_index]
+                        added_points_Y.append(added_point)
+                        added_points_X.append(Unknown_best_X[max_distance_index])
+                        Known_best_Y = np.append(Known_best_Y, [added_point], axis=0)
+                        
+                        Unknown_best_Y = np.delete(Unknown_best_Y, max_distance_index, axis=0)
+                        Unknown_best_X = np.delete(Unknown_best_X, max_distance_index, axis=0)
+                    
+                    BestX = np.copy(np.array(added_points_X))
+                    BestY = np.copy(np.array(added_points_Y))
+                    bestOff = Population(decs = BestX, objs = BestY)
+            
+            self.evaluate(bestOff)
+            pop.add(bestOff)
+            self.record(pop)
+                
+        return self.result
+          
+        
+                
+        
+            
+        
+            
+            
+        
+        
+        

{UQPyL-2.0.9 → UQPyL-2.0.11}/UQPyL/optimization/multi_objective/moea_d.py

@@ -1,12 +1,13 @@
 #multiobjective evolutionary algorithm based on decomposition (MOEAD) <Multi>
 import numpy as np
 import math
-from typing import Optional, Literal
+from typing import Literal
 from scipy.spatial import distance
 
 from ..algorithmABC import Algorithm
 from ..population import Population
-from ..utility_functions import uniformPoint, operationGAHalf, NDSort
+from ..utility_functions import uniformPoint, NDSort
+from ..utility_functions.operation_GA import operationGAHalf
 from ...utility import Verbose
 class MOEAD(Algorithm):
     '''
@@ -37,89 +38,93 @@ class MOEAD(Algorithm):
                 the maximum number of iterations
     '''
     
-    name="MOEA/D"
+    name="MOEA_D"
     type="MOEA"
     
     def __init__(self, aggregation: Literal['PBI', 'TCH', 'TCH_N', 'TCH_M']= 'PBI',
-                nInit: int=50, nPop: int=50,
+                nPop: int=50,
                 maxFEs: int = 50000, 
                 maxIterTimes: int = 1000, 
                 maxTolerateTimes=None, tolerate=1e-6, 
-                verbose=True, verboseFreq=10, logFlag=True, saveFlag=False):
+                verbose=True, verboseFreq=10, logFlag=True, saveFlag=True):
+        
         #problem setting
         super().__init__(maxFEs, maxIterTimes, maxTolerateTimes, tolerate, verbose, verboseFreq, logFlag, saveFlag)
         
         self.setParameters('aggregation', aggregation)
-        self.setParameters('nInit', nInit)
         self.setParameters('nPop', nPop)
         
+        
     #-------------------Public Functions-----------------------#
     @Verbose.decoratorRun
     @Algorithm.initializeRun
-    def run(self, problem, xInit=None, yInit=None):
+    def run(self, problem):
         
         #Parameter Setting
         aggregation=self.getParaValue('aggregation')
-        nInit, nPop=self.getParaValue('nInit', 'nPop')
+        nPop=self.getParaValue('nPop')
+        
         #Problem
         self.setProblem(problem)
+        
         #Termination Condition Setting
         self.FEs=0; self.iters=0
-        #Population Generation
-        if xInit is not None:
-            pop = Population(xInit, yInit) if yInit is not None else Population(xInit)
-            if yInit is None:
-                self.evaluate(pop)
-        else:
-            pop = self.initialize(nInit)
-        
-        pop=pop.getTop(nPop)
         
         T = math.ceil(nPop / 10)
-        W, N=uniformPoint(nPop, problem.nOutput)
+        W, N = uniformPoint(nPop, problem.nOutput)
+        
+        nPop = N
         
-        B=distance.cdist(W, W, metric='euclidean')
-        B=np.argsort(B, axis=1)
-        B=B[:,0:T]
+        B = distance.cdist(W, W, metric='euclidean')
+        B = np.argsort(B, axis=1)
+        B = B[:,0:T]
         
-        Z=np.min(pop.objs, axis=0).reshape(1,-1)
+        #Population Generation
+        pop = self.initialize(nPop)
         
+        Z = np.min(pop.objs, axis=0).reshape(1,-1)
+         
         while self.checkTermination():
-            for i in range(N):
+            
+            for i in range(nPop):
                 
                 P = B[i, np.random.permutation(B.shape[1])].ravel()
 
-                offspring=operationGAHalf(pop[P[0:2]], problem.ub, problem.lb, 1, 20, 1, 20)
+                offspring = operationGAHalf(pop[P[0:2]], problem.ub, problem.lb, 1, 20, 1, 20)
+                
                 self.evaluate(offspring)
                 
-                Z=np.min(np.vstack((Z, offspring.objs)), axis=0).reshape(1, -1)
+                Z = np.min(np.vstack((Z, offspring.objs)), axis=0).reshape(1, -1)
+                
+                popObjs = pop.objs[P]
+                offspringObjs = offspring.objs
                 
                 #PBI
                 if(aggregation=='PBI'):
                     
                     normW = np.sqrt(np.sum(W[P, :]**2, axis=1))
-                    normP = np.sqrt(np.sum((pop.objs[P] - np.tile(Z, (T, 1)))**2, axis=1))
-                    normO = np.sqrt(np.sum((offspring.objs - Z)**2, axis=1))
+                    normP = np.sqrt(np.sum((popObjs - np.tile(Z, (T, 1)))**2, axis=1))
+                    normO = np.sqrt(np.sum((offspringObjs - Z)**2, axis=1))
                     CosineP = np.sum((pop.objs[P] - np.tile(Z, (T, 1))) * W[P, :], axis=1) / normW / normP
-                    CosineO = np.sum(np.tile(offspring.objs - Z, (T, 1)) * W[P, :], axis=1) / normW / normO
+                    CosineO = np.sum(np.tile(offspringObjs - Z, (T, 1)) * W[P, :], axis=1) / normW / normO
                     g_old = normP * CosineP + 5 * normP * np.sqrt(1 - CosineP**2)
                     g_new = normO * CosineO + 5 * normO * np.sqrt(1 - CosineO**2)
                     
                 elif(aggregation=='TCH'):
                     
-                    g_old = np.max(np.abs(pop.objs[P] - np.tile(Z, (T, 1))) * W[P, :], axis=1)
-                    g_new = np.max(np.tile(np.abs(offspring.objs- Z), (T, 1)) * W[P, :], axis=1)
+                    g_old = np.max(np.abs(popObjs - np.tile(Z, (T, 1))) * W[P, :], axis=1)
+                    g_new = np.max(np.tile(np.abs(offspringObjs- Z), (T, 1)) * W[P, :], axis=1)
                     
                 elif(aggregation=='TCH_N'):
                     
                     Zmax = np.max(pop.objs, axis=0)
-                    g_old = np.max(np.abs(pop.objs[P] - np.tile(Z, (T, 1))) / np.tile(Zmax - Z, (T, 1)) * W[P, :], axis=1)
-                    g_new = np.max(np.tile(np.abs(offspring.objs - Z) / (Zmax - Z), (T, 1)) * W[P, :], axis=1)
+                    g_old = np.max(np.abs(popObjs - np.tile(Z, (T, 1))) / np.tile(Zmax - Z, (T, 1)) * W[P, :], axis=1)
+                    g_new = np.max(np.tile(np.abs(offspringObjs - Z) / (Zmax - Z), (T, 1)) * W[P, :], axis=1)
                     
                 elif(aggregation=='TCH_M'):
                     
-                    g_old = np.max(np.abs(pop.objs[P] - np.tile(Z, (T, 1))) / W[P, :], axis=1)
-                    g_new = np.max(np.tile(np.abs(offspring.objs - Z), (T, 1)) / W[P, :], axis=1)
+                    g_old = np.max(np.abs(popObjs - np.tile(Z, (T, 1))) / W[P, :], axis=1)
+                    g_new = np.max(np.tile(np.abs(offspringObjs - Z), (T, 1)) / W[P, :], axis=1)
                 
                 pop.replace(P[g_old >= g_new], offspring)
                 

{UQPyL-2.0.9 → UQPyL-2.0.11}/UQPyL/optimization/multi_objective/nsga_ii.py

@@ -1,13 +1,12 @@
 # Non-dominated Sorting Genetic Algorithm II (NSGA-II) <Multi>
 import numpy as np
-import math
-from typing import Optional
 
-from ..utility_functions import NDSort, crowdingDistance, tournamentSelection, operationGA
-from ...DoE import LHS
+
+from ..utility_functions import NDSort, crowdingDistance, tournamentSelection
+from ..utility_functions.operation_GA import operationGA
+
 from ..algorithmABC import Algorithm
 from ..population import Population
-from ...problems import ProblemABC  as Problem
 from ...utility import Verbose
 class NSGAII(Algorithm):
     '''
@@ -53,11 +52,11 @@ class NSGAII(Algorithm):
     type = "MOEA"
     
     def __init__(self, proC: float=1.0, disC: float=20.0, proM: float=1.0, disM: float=20.0,
-                 nInit: int =50, nPop: int =50,
+                 nPop: int =50,
                  maxFEs: int = 50000, 
                  maxIterTimes: int = 1000, 
                  maxTolerateTimes=None, tolerate=1e-6, 
-                 verbose=True, verboseFreq=10, logFlag=True, saveFlag=False):
+                 verbose=True, verboseFreq=10, logFlag=True, saveFlag=True):
         
         super().__init__(maxFEs, maxIterTimes, maxTolerateTimes, tolerate, verbose, verboseFreq, logFlag, saveFlag)
         
@@ -65,30 +64,25 @@ class NSGAII(Algorithm):
         self.setParameters('disC', disC)
         self.setParameters('proM', proM)
         self.setParameters('disM', disM)
-        self.setParameters('nInit', nInit)
         self.setParameters('nPop', nPop)
         
     #-------------------------Public Functions------------------------#
     @Verbose.decoratorRun
     @Algorithm.initializeRun
-    def run(self, problem, xInit=None, yInit=None):
+    def run(self, problem):
         
         #Parameter Setting
         proC, disC, proM, disM=self.getParaValue('proC', 'disC', 'proM', 'disM')
-        nInit, nPop=self.getParaValue('nInit', 'nPop')
+        nPop=self.getParaValue('nPop')
+        
         #Problem
         self.setProblem(problem)
+        
         #Termination Condition Setting
         self.FEs=0; self.iters=0
+        
         #Population Generation
-        if xInit is not None:
-            pop = Population(xInit, yInit) if yInit is not None else Population(xInit)
-            if yInit is None:
-                self.evaluate(pop)
-        else:
-            pop = self.initialize(nInit)
-            
-        pop=pop.getTop(nPop)
+        pop = self.initialize(nPop)
         
         _, frontNo, CrowdDis=self.environmentalSelection(pop, nPop)