Changeset 576 for branches

Timestamp:

10/04/12 11:14:05 (4 years ago)

Author:

mmckerns

Message:

updated Lan's collapse code so 'collapse_solver' is imported

Location:

branches/collapse

Files:

• TEST_OUQ_surrogate_diam_collapse.py (moved) (moved from branches/collapse/TEST_OUQ_surrogate_diam.py) (2 diffs)
• collapse_code.py (added)

branches/collapse/TEST_OUQ_surrogate_diam_collapse.py

@@ -47 +47 @@
   solver.SetGenerationMonitor(stepmon)
   solver.SetConstraints(_constraints)
- 
-  ##############################################################################
-  
-                 ## THE FOLLOWING TERMINATION AND CONSTRAINTS ##
-                 ## CAN BE MOVED TO A NEW MODULE AND IMPORTED ##
-  
-  ######################### TERMINATION CONDITIONS #############################
-  from mystic.termination import Or  
-  from mystic.termination import ChangeOverGeneration as COG
-  from collapse_termination_v2 import CLPS_Weight as WCLPS
-  from collapse_termination_v2 import CLPS_Position as PCLPS  
-  from mystic.math.measures import _nested_split  
-  
-  tol = convergence_tol
-  _COG = COG(tol,ngen)
-  
-  w_lb, x_lb = _nested_split(lb, npts)
-  w_ub, x_ub = _nested_split(ub, npts)
-  range_x = []
-  for i in range(len(x_lb)):
-      range_x.append(abs(x_lb[i][0] - x_ub[i][0]))  
-  tolP = [ele*tolP_range_fr for ele in range_x] 
-  if debug: print 'tolP = %s' %tolP
-  
-  indexW_ids = [range(nx) for nx in npts]  # list of indices for CLPS_Weight termination check
-  indexP_ids = []  # list of indices for CLPS_Position termination check  
-  
-  x = []
-  _WCLPS = []
-  _PCLPS = []
-  
-  for m in range(len(indexW_ids)):
-      for idx in indexW_ids[m]:
-          _WCLPS.append(WCLPS(npts, tol_weight = tolW, generations=ngcol, axisW = m, indexW = idx))
-          
-  for m in range(len(indexP_ids)):
-      for pair in indexP_ids[m]:
-          _PCLPS.append( PCLPS(npts, tol_position=tolP, generations=ngcol, \
-                                axisP = m, index1 = pair[0], index2  = pair[1])) 
-  x.extend(_WCLPS)
-  x.extend(_PCLPS)
-  x.append(_COG)
-  trm = Or(*x)
-  
-  ######################## NEW CONSTRAINTS AFTER COLLAPSE ######################
-  
-  list_vanished_weights = [] # list of [measure, index] lists
-  list_collapsed_pairs = [] # list of [measure, pair] lists, where pair = [index1, index2]  
-  
-  for i in range(len(npts)):
-    c = []
-    for idx in range(npts[i]):
-        for jdx in range(idx,npts[i]):
-            if idx !=jdx:
-                c.append([idx, jdx])
-    indexP_ids.append(c)  
-  
-  def _set_weight_to_zero(rv, npts, axisW, indexW):
-    from mystic.math.dirac_measure import product_measure
-    c = product_measure()
-    c.load(rv, npts)
-    c[axisW][indexW].weight = 0
-    return c.flatten()
-  
-  def _set_same_positions(rv, npts, axisP, index1, index2):
-    from mystic.math.dirac_measure import product_measure
-    c = product_measure()
-    c.load(rv, npts)
-    c[axisP][index1].weight += c[axisP][index2].weight
-    c[axisP][index2].weight = 0
-    c[axisP][index2].position = c[axisP][index1].position
-    return c.flatten() 
-  
-  def new_constraints(rv, list_collapsed_pairs, list_vanished_weights):
-    for ele in list_vanished_weights:
-      rv = _set_weight_to_zero(rv, npts, axisW = ele[0], indexW = ele[1])
-    for mem in list_collapsed_pairs:
-      rv = _set_same_positions(rv, npts, axisP = mem[0], \
-              index1 = mem[1][0], index2 = mem[1][1])            
-    return _constraints(rv)   
-  
-  ##############################################################################
-  
-  
-  ############################ RUN THE SOLVER ##################################
-  collapse_data = {}
-  tot_evaluations = 0 # total number of function eveluations
-  while _COG(solver) != True:         
-    solver.Solve(cost,termination=trm,strategy=Best1Exp, \
-               CrossProbability=crossover,ScalingFactor=percent_change) 
-    tot_evaluations += solver.evaluations    
-    collapse_data[stepmon._step] = trm(solver, True)
-    
-    if debug:
-      print 'last_itr_evaluations = %s' %solver.evaluations
-      print "Generation  %d " %stepmon._step 
-    
-    int_trm = trm(solver, info = 'self')  
-    for ele in range(len(int_trm)):
-      cond = int_trm[ele]
-      string = cond(solver, info = True)
-      string1 = string.replace(',', ' ')
-      string2 = string1.replace('&', ' ')
-      string3 = string2.replace(':', ' ')
-      lst = string3.split()
-      
-      if lst[0] == 'CLPS_Weight':
-          for i in range(len(lst)):
-              if lst[i] == 'measure':
-                  axisW = int(lst[i+1])
-                  if lst[i+2] == 'index': indexW = int(lst[i+3])
-                  
-          if debug:
-            print 'axisW = %s' %axisW
-            print 'indexW = %s' %indexW
-          
-          list_vanished_weights.append([axisW, indexW]) 
-          indexW_ids[axisW].remove(indexW)
-                 
-      if lst[0] == 'CLPS_Position':
-          for i in range(len(lst)):  
-              if lst[i] == 'measure':        
-                  axisP = int(lst[i+1])
-                  if lst[i+2] == 'indices': 
-                      index1 = int(lst[i+3].lstrip('('))
-                      index2 = int(lst[i+4].rstrip(')'))
-          if debug:
-            print "axisP = %s" %axisP
-            print "index1 = %s" %index1
-            print "index2 = %s" %index2
-          
-          list_collapsed_pairs.append([axisP, [index1, index2]])
-          indexP_ids[axisP].remove([index1,index2])          
-      
-      ##### AFTER COLLAPSE OCCURRED CHANGE THE TERMINATION AND CONSTRAINTS #####
-                    
-      def _new_constraints(rv):
-        return new_constraints(rv, list_collapsed_pairs, list_vanished_weights)      
-      solver.SetConstraints(_new_constraints)
-      
-      x = []
-      _WCLPS = []
-      _PCLPS = []
-      for m in range(len(indexW_ids)):
-          for idx in indexW_ids[m]:
-              _WCLPS.append(WCLPS(npts, generations=ngcol, axisW = m, indexW = idx))
-              
-      for m in range(len(indexP_ids)):
-          for pair in indexP_ids[m]:
-              _PCLPS.append( PCLPS(npts, tol_position=tolP, generations=ngcol, \
-                                    axisP = m, index1 = pair[0], index2  = pair[1])) 
-      x.extend(_WCLPS)
-      x.extend(_PCLPS)
-      x.append(_COG)
-      trm = Or(*x)
-      
-      if debug:
-        print 'list_vanished_weights = '
-        print  list_vanished_weights
-        print 'list_collapsed_pairs = '
-        print  list_collapsed_pairs                         
-  
-  solved = solver.bestSolution
- #print "solved: %s" % solver.Solution()
-  func_max = MINMAX * solver.bestEnergy       #NOTE: -solution assumes -Max
- #func_max = 1.0 + MINMAX*solver.bestEnergy   #NOTE: 1-sol => 1-success = fail
-  func_evals = solver.evaluations
-  from mystic.munge import write_support_file
-  write_support_file(stepmon)
-  '''
-  if collapse_data:
-    f = open('collapse_data.txt','w')
-    f.write('COLLAPSE DATA = %s' %collapse_data)
-    f.close()'''
-  return solved, func_max, tot_evaluations, collapse_data
-
-
+  
+  import collapse_code  
+  return collapse_code.collapseSolver(solver, cost, npts, lb, ub, convergence_tol, tolW, \
+                        tolP_range_fr, ngen, ngcol, Best1Exp, crossover, \
+                        percent_change, stepmon, _constraints)
 #######################################################################
 # maximize the function
@@ -301 +129 @@
   H_mean = 6.5    #NOTE: SET THE 'mean' HERE!
   H_range = 1.0   #NOTE: SET THE 'range' HERE!
-  nx = 5  #NOTE: SET THE NUMBER OF 'h' POINTS HERE!
-  ny = 5  #NOTE: SET THE NUMBER OF 'a' POINTS HERE!
-  nz = 5  #NOTE: SET THE NUMBER OF 'v' POINTS HERE!
+  nx = 3  #NOTE: SET THE NUMBER OF 'h' POINTS HERE!
+  ny = 3  #NOTE: SET THE NUMBER OF 'a' POINTS HERE!
+  nz = 3  #NOTE: SET THE NUMBER OF 'v' POINTS HERE!
   target = (H_mean,)
   error = (H_range,)