[WIP]: Enabling min max list

dependencies.xml

@@ -96,4 +96,4 @@ Note all install methods after "main" take
     <nomkl>remove</nomkl>
     <numexpr>remove</numexpr>
   </alternate>
-</dependencies>
+</dependencies>

ravenframework/CodeInterfaceClasses/SIMULATE3/SimulateData.py

@@ -43,6 +43,8 @@ def __init__(self,filen):
     self.data["PinPowerPeaking"] = self.pinPeaking()
     self.data["exposure"] = self.burnupEOC()
     self.data["assembly_power"] = self.assemblyPeakingFactors()
+    self.data["fuel_type"] = self.fa_type()
+#    self.data["pin_peaking"] = self.pinPeaking()
     # this is a dummy variable for demonstration with MOF
     # check if something has been found
     if all(v is None for v in self.data.values()):
@@ -211,7 +213,7 @@ def EOCEFPD(self):
     if not list_:
       return ValueError("No values returned. Check Simulate File executed correctly")
     else:
-      outputDict = {'info_ids':['MaxEFPD'], 'values': [list_[-1]] }
+      outputDict = {'info_ids':['MaxEFPD'], 'values': [list_[-1]]}
 
     return outputDict
 
@@ -486,6 +488,45 @@ def burnupEOC(self):
 
     return outputDict
 
+  def fa_type(self):
+    '''
+    Extracts the fuel type and calculates the fuel cost based on the amount and enrichment of each fuel type.
+    '''
+    #fuel_type = []
+    FAlist = []
+    for line in self.lines:
+      if "'FUE.TYP'" in line:
+        p1 = line.index(",")
+        p2 = line.index("/")
+        search_space = line[p1:p2]
+        search_space = search_space.replace(",","")
+        tmp= search_space.split()
+        for ii in tmp:
+          FAlist.append(float(ii))
+    FAtype = list(set(FAlist))
+    FAlist_A = FAlist[0]
+    FAlist_B = FAlist[1:9] + FAlist[9:73:9]
+    FAlist_C = FAlist[10:18] + FAlist[19:27] + FAlist[28:36] + FAlist[37:45] + FAlist[46:54] + FAlist[55:63] + FAlist[64:72] + FAlist[73:81]
+    FAcount_A = [float(fa == FAlist_A) for fa in FAtype]
+    FAcount_B = [float(FAlist_B.count(fa)*2) for fa in FAtype]
+    FAcount_C = [float(FAlist_C.count(fa)*4) for fa in FAtype]
+    FAcount = [FAcount_A[j] + FAcount_B[j] + FAcount_C[j] for j in range(len(FAtype))]
+    print(FAcount)
+    #stop
+    #Considering that: FA type 0 is empty, type 1 reflector, type 2 2% enrichment, types 3 and 4 2.5% enrichment, and types 5 and 6 3.2% enrichment. The cost of burnable is not being considered
+    if len(FAcount) == 7:
+      fuel_cost = (FAcount[0] + FAcount[1])*0 + FAcount[2]*2.69520839 + (FAcount[3] + FAcount[4])*3.24678409 + (FAcount[5] + FAcount[6])*4.03739539
+    else:
+      fuel_cost = (FAcount[0] + FAcount[1])*0 + FAcount[2]*2.69520839 + (FAcount[3] + FAcount[4])*3.24678409 + (FAcount[5])*4.03739539
+    print(fuel_cost)
+    #fuel_type.append(float(search_space))
+    #stop
+    if not fuel_cost:
+      return ValueError("No values returned. Check Simulate File executed correctly")
+    else:
+      outputDict = {'info_ids':['fuel_cost'], 'values': [fuel_cost]}
+      return outputDict
+
   def writeCSV(self, fileout):
     """
       Print Data into CSV format
@@ -505,4 +546,3 @@ def writeCSV(self, fileout):
           index=index+1
     numpy.savetxt(fileObject, outputMatrix.T, delimiter=',', header=','.join(headers), comments='')
     fileObject.close()
-

ravenframework/Optimizers/GradientDescent.py

@@ -212,6 +212,7 @@ def __init__(self):
     self._followerProximity = 1e-2   # distance at which annihilation can start occurring, in ?normalized? space
     self._trajectoryFollowers = defaultdict(list) # map of trajectories to the trajectories following them
     self._functionalConstraintExplorationLimit = 500 # number of input-space explorations allowable for functional constraints
+    self._canHandleMultiObjective = False # Currently Gradient Descent cannot handle multiobjective optimization
     # __private
     # additional methods
     # register adaptive sample identification criteria
@@ -338,7 +339,11 @@ def _useRealization(self, info, rlz):
       @ Out, None
     """
     traj = info['traj']
-    optVal = rlz[self._objectiveVar]
+    # if not self._canHandleMultiObjective and len(self._objectiveVar) == 1:
+    #   self._objectiveVar = self._objectiveVar[0]
+    if len(self._objectiveVar) > 1 and type(self._objectiveVar)==list:
+      self.raiseAnError(IOError, 'Gradient Descent does not support multiObjective optimization yet! objective variable must be a single variable for now!')
+    optVal = rlz[self._objectiveVar[0]]
     info['optVal'] = optVal
     purpose = info['purpose']
     if purpose.startswith('opt'):
@@ -353,13 +358,13 @@ def _useRealization(self, info, rlz):
       gradMag, gradVersor, _ = self._gradientInstance.evaluate(opt,
                                                                grads,
                                                                gradInfos,
-                                                               self._objectiveVar)
+                                                               self._objectiveVar[0])
       self.raiseADebug(' ... gradient calculated ...')
       self._gradHistory[traj].append((gradMag, gradVersor))
       # get new step information
       try:
         newOpt, stepSize, stepInfo = self._stepInstance.step(opt,
-                                                  objVar=self._objectiveVar,
+                                                  objVar=self._objectiveVar[0],
                                                   optHist=self._optPointHistory[traj],
                                                   gradientHist=self._gradHistory[traj],
                                                   prevStepSize=self._stepHistory[traj],
@@ -378,7 +383,7 @@ def _useRealization(self, info, rlz):
       except NoConstraintResolutionFound:
         # we've tried everything, but we just can't hack it
         self.raiseAMessage(f'Optimizer "{self.name}" trajectory {traj} was unable to continue due to functional or boundary constraints.')
-        self._closeTrajectory(traj, 'converge', 'no constraint resolution', opt[self._objectiveVar])
+        self._closeTrajectory(traj, 'converge', 'no constraint resolution', opt[self._objectiveVar[0]])
         return
 
       # update values if modified by constraint handling
@@ -598,7 +603,7 @@ def _checkAcceptability(self, traj, opt, optVal, info):
     # Check acceptability
     if self._optPointHistory[traj]:
       old, _ = self._optPointHistory[traj][-1]
-      oldVal = old[self._objectiveVar]
+      oldVal = old[self._objectiveVar[0]]
       # check if following another trajectory
       if self._terminateFollowers:
         following = self._stepInstance.trajIsFollowing(traj, self.denormalizeData(opt), info,
@@ -815,7 +820,7 @@ def _checkConvObjective(self, traj):
       return False
     o1, _ = self._optPointHistory[traj][-1]
     o2, _ = self._optPointHistory[traj][-2]
-    delta = mathUtils.relativeDiff(o2[self._objectiveVar], o1[self._objectiveVar])
+    delta = mathUtils.relativeDiff(o2[self._objectiveVar[0]], o1[self._objectiveVar[0]])
     converged = abs(delta) < self._convergenceCriteria['objective']
     self.raiseADebug(self.convFormat.format(name='objective',
                                             conv=str(converged),

ravenframework/Optimizers/Optimizer.py

@@ -78,9 +78,9 @@ def getInputSpecification(cls):
     specs.description = 'Optimizers'
 
     # objective variable
-    specs.addSub(InputData.parameterInputFactory('objective', contentType=InputTypes.StringType, strictMode=True,
+    specs.addSub(InputData.parameterInputFactory('objective', contentType=InputTypes.StringListType, strictMode=True,
         printPriority=90, # more important than <variable>
-        descr=r"""Name of the response variable (or ``objective function'') that should be optimized
+        descr=r"""Name of the objective variable (or ``objective function'') that should be optimized
         (minimized or maximized)."""))
 
     # modify Sampler variable nodes
@@ -103,7 +103,8 @@ def getInputSpecification(cls):
         descr=r"""seed for random number generation. Note that by default RAVEN uses an internal seed,
               so this seed must be changed to observe changed behavior. \default{RAVEN-determined}""")
     minMaxEnum = InputTypes.makeEnumType('MinMax', 'MinMaxType', ['min', 'max'])
-    minMax = InputData.parameterInputFactory('type', contentType=minMaxEnum,
+    minMaxList = InputTypes.StringListType()
+    minMax = InputData.parameterInputFactory('type', contentType=minMaxList,
         descr=r"""the type of optimization to perform. \xmlString{min} will search for the lowest
               \xmlNode{objective} value, while \xmlString{max} will search for the highest value.""")
     init.addSub(seed)
@@ -161,7 +162,7 @@ def __init__(self):
     # public
     # _protected
     self._seed = None                   # random seed to apply
-    self._minMax = 'min'                # maximization or minimization?
+    self._minMax = ['min']                # maximization or minimization?
     self._activeTraj = []               # tracks live trajectories
     self._cancelledTraj = {}            # tracks cancelled trajectories, and reasons
     self._convergedTraj = {}            # tracks converged trajectories, and values obtained
@@ -249,7 +250,6 @@ def handleInput(self, paramInput):
       @ Out, None
     """
     # the reading of variables (dist or func) and constants already happened in _readMoreXMLbase in Sampler
-    # objective var
     self._objectiveVar = paramInput.findFirst('objective').value
 
     # sampler init
@@ -264,6 +264,10 @@ def handleInput(self, paramInput):
       minMax = init.findFirst('type')
       if minMax is not None:
         self._minMax = minMax.value
+        if len(self._minMax) != len(self._objectiveVar):
+          self.raiseAnError(IOError, 'type and objective must be of the same length!')
+        if list(set(self._minMax)-set(['min','max'])) != []:
+          self.raiseAnError(IOError, "type must be a list of 'min' and/or 'max'")
 
     # variables additional reading
     for varNode in paramInput.findAll('variable'):