source: branches/OaaS/HeuristicLab.Services.Optimization.Web/Mappings/mapping.py @ 14821

from HeuristicLab.Data import DoubleValue, DoubleMatrix, BoolValue, IntValue, PercentValue
from HeuristicLab.Encodings.PermutationEncoding import Permutation, PermutationTypes
from HeuristicLab.Problems.TravelingSalesman import TSPRoundedEuclideanPathEvaluator, TSPGeoPathEvaluator, TSPEuclideanPathEvaluator
from System import Array

class HeuristicLabMapper:
  def __init__(self):
    self.__params = source.InputParameters

  def UseParameters(self, params):
    self.__params = params

  def MapDoubleValue(self, name):
    return DoubleValue(self.__params.FindByName(name).Value.Value)

  def MapPermutation(self, name):
    entries = Array.CreateInstance(int, self.__params.FindByName(name).Value.Value.Length)
    i = 0
    for value in self.__params.FindByName(name).Value.Value:
      entries[i] = int(value)
      i = i + 1
    return Permutation(PermutationTypes.RelativeDirected, entries)  

  def MapDoubleMatrix(self, name):
    matrixEntries = self.__params.FindByName(name).Value.Value; 
    result = Array.CreateInstance(float, matrixEntries.Length, matrixEntries[0].Length)
    for i in range(matrixEntries.Length):    
      for j in range(matrixEntries[i].Length):    
        result[i, j] = matrixEntries[i][j]
    return DoubleMatrix(result)  

  def MapBoolValue(self, name):
    return BoolValue(self.__params.FindByName(name).Value.Value)

  def MapIntValue(self, name):
    return IntValue(int(source.AlgorithmParameters.FindByName(name).Value.Value))

  def MapPercentValue(self, name):
    return PercentValue(self.__params.FindByName(name).Value.Value / 100)

  def GetStringValue(self, name):
    return self.__params.FindByName(name).Value.Value

  def FindIn(self, name, lst):
    param = self.__params.FindByName(name).Value.Value    
    for operator in lst:  
      if operator.Name == param:
        return operator         
    print "ERROR: Couldn't find " + name + " " + param
    print "List: "
    print lst   
    return None

  def FindOperator(self, name):
    param = self.__params.FindByName(name).Value.Value    
    for operator in problem.Operators:  
      if operator.Name == param:
        return operator      
    return None


mapper = HeuristicLabMapper()
mapper.UseParameters(source.InputParameters)
###### PROBLEM PARAMETERS ######
problem.BestKnownQuality = mapper.MapDoubleValue("BestKnownQuality")
problem.BestKnownSolution = mapper.MapPermutation("BestKnownSolution")
problem.Coordinates = mapper.MapDoubleMatrix("Coordinates")
evaluatorParameter = mapper.GetStringValue("EvaluatorParameter")
if (evaluatorParameter == "HeuristicLab.Problems.TravelingSalesman.TSPRoundedEuclideanPathEvaluator"):
  problem.EvaluatorParameter.Value = TSPRoundedEuclideanPathEvaluator()
elif (evaluatorParameter == "HeuristicLab.Problems.TravelingSalesman.TSPGeoPathEvaluator"):
  problem.EvaluatorParameter.Value = TSPGeoPathEvaluator()
else:
  problem.EvaluatorParameter.Value = TSPEuclideanPathEvaluator()
problem.UseDistanceMatrix = mapper.MapBoolValue("UseDistanceMatrix")

###### ALGORITHM PARAMETERS ######
mapper.UseParameters(source.AlgorithmParameters)
# CrossoverParameter - string
algorithm.CrossoverParameter.Value = mapper.FindOperator("CrossoverParameter")
algorithm.Elites = mapper.MapIntValue("Elites")
algorithm.MaximumGenerations = mapper.MapIntValue("MaximumGenerations")
algorithm.MutationProbability = mapper.MapPercentValue("MutationProbability")
algorithm.Mutator = mapper.FindIn("Mutator", algorithm.MutatorParameter.ValidValues)
algorithm.PopulationSize = mapper.MapIntValue("PopulationSize")
algorithm.Seed = mapper.MapIntValue("Seed")
algorithm.Selector = mapper.FindIn("Selector", algorithm.SelectorParameter.ValidValues)
algorithm.SetSeedRandomly = mapper.MapBoolValue("SetSeedRandomly")