Changeset 9305 for branches/OaaS/HeuristicLab.Services.Optimization.Controller/Parsers

Timestamp:

03/11/13 14:40:04 (12 years ago)

Author:

fschoepp

Message:

#1888:

• Added an Update / GetExperiment... methods to the controller for updating and querying experiments.
• The AlgorithmConverter class now properly converts from/to JSON format.
• Integrated backbone js as MVC provider for JavaScript + jquery.
• Added experiment.model.js + experiment.view.js + experiment.controller.js containing the MVC impl. for the Experiment pages.
• Added new methods to the ExperimentController usable by the backbone js model implementation.
• Added the experiment dialog from HL 3.3.7 (variate experiment parameters). It's capable of variating the algorithm parameters.

File:

• branches/OaaS/HeuristicLab.Services.Optimization.Controller/Parsers/AlgorithmConverter.cs (modified) (5 diffs)

branches/OaaS/HeuristicLab.Services.Optimization.Controller/Parsers/AlgorithmConverter.cs

@@ -9 +9 @@
 namespace HeuristicLab.Services.Optimization.ControllerService.Parsers {
   public static class AlgorithmConverter {
-
-    public static Algorithm Convert(string json) {
-      var o = JObject.Parse(json);
-      return ParseAlgorithm(o);      
-    }
-
-    private static Algorithm ParseAlgorithm(JToken obj) {
-      var algorithm = new Algorithm();
-
-      foreach (JProperty param in obj["Algorithm Parameters"]) {
-        Parameter parameter = CreateParameter(param);
-        algorithm.Parameters.Items.Add(parameter);
-      }
-
-      var problemParams = obj["Problem Parameters"];
-      if (problemParams != null) {
-        algorithm.Problem = new Problem();
-        foreach (JProperty param in problemParams) {
-          Parameter parameter = CreateParameter(param);
-          algorithm.Problem.Parameters.Items.Add(parameter);
-        }
-      }
-      return algorithm;
-    }
-
-    public static Algorithm ConvertAppend(string json, Algorithm algorithm) {
-      var o = JObject.Parse(json);
-      foreach (JProperty param in o["Algorithm Parameters"]) {
-        Parameter parameter = CreateParameter(param);
-        var oldParameter = (from p in algorithm.Parameters.Items where p.Value.Name == parameter.Value.Name select p).FirstOrDefault();
-        if (oldParameter != null) {
-          oldParameter.Value = parameter.Value;
-        }
-        else {
-          algorithm.Parameters.Items.Add(parameter);
-        }
-      }
-
-      var problemParams = o["Problem Parameters"];
-      if (problemParams != null) {
-        algorithm.Problem = new Problem();
-        foreach (JProperty param in problemParams) {
-          Parameter parameter = CreateParameter(param);          
-          var oldParameter = (from p in algorithm.Problem.Parameters.Items where p.Value.Name == parameter.Value.Name select p).FirstOrDefault();
-          if (oldParameter != null) {
-            oldParameter.Value = parameter.Value;
-          }
-          else {
-            algorithm.Problem.Parameters.Items.Add(parameter);
-          }
-        }
-      }
-      return algorithm;
-    }
-
-    private static Parameter CreateParameter(JProperty property) {
-      JToken token = property.Value;
-      switch (token.Type) {
+    #region private methods
+    private static Parameter CreateParameter(JObject property) {
+      var name = (string)property["Name"];
+      var value = property["Value"];
+      switch (value.Type) {
         case JTokenType.Integer:
         case JTokenType.Float:
-          return new Parameter() { Type = ParameterType.Decimal, Value = new DecimalValue() { Name = property.Name, Value = (double)property.Value } };
+          return new Parameter() { Type = ParameterType.Decimal, Value = new DecimalValue() { Name = name, Value = (double)value } };
         case JTokenType.Boolean:
-          return new Parameter() { Type = ParameterType.Boolean, Value = new BoolValue() { Name = property.Name, Value = (bool)property.Value } };
+          return new Parameter() { Type = ParameterType.Boolean, Value = new BoolValue() { Name = name, Value = (bool)value } };
         case JTokenType.String:
-          return new Parameter() { Type = ParameterType.Type, Value = new TypeValue() { Name = property.Name, Value = (string)property.Value } };                  
+          return new Parameter() { Type = ParameterType.Type, Value = new TypeValue() { Name = name, Value = (string)value, Options = (from e in property["Options"] select (string)e).ToArray() } };
         case JTokenType.Array:
-          var arr = (JArray)token;
+          var arr = (JArray)value;
           // its a matrix
           if (arr[0].Type == JTokenType.Array) {
-            return CreateMatrixParameter(property.Name, arr);
+            return CreateMatrixParameter(name, arr);
           }
-          return CreateVectorParameter(property.Name, arr);
+          return CreateVectorParameter(name, arr);
         default:
           throw new Exception("Unhandled datatype: " + property.Type);
@@ -89 +36 @@
       double[][] entries = new double[arr.Count][];
       for (int i = 0; i < entries.Length; i++) {
-        entries[i] = (from d in arr[i] select (double)d).ToArray<double>();  
+        entries[i] = (from d in arr[i] select (double)d).ToArray<double>();
       }
       return new Parameter { Type = ParameterType.DecimalMatrix, Value = new DecimalMatrix() { Name = name, Value = entries } };
@@ -99 +46 @@
     }
 
-    public static string ConvertJson(Algorithm algorithm) {
-      return JsonConvert.SerializeObject(algorithm);
-    }
-
-    
     private class StackEntry {
       public Algorithm Parent { get; set; }
@@ -109 +51 @@
     }
 
-    public static Experiment ConvertExperimentSimple(string json) {
-      return JsonConvert.DeserializeObject<Experiment>(json, new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.Auto });
-    }
-
-    public static string ConvertJson(Experiment experiment) {
-      return JsonConvert.SerializeObject(experiment, Formatting.None, new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.Auto });
-    }
-
-    public static Experiment ConvertExperiment(string json) {
+    private static JArray ConvertParametersToJson(IList<Parameter> parameters) {
+      var array = new JArray();
+      foreach (var param in parameters) {
+        array.Add(JObject.FromObject(param.Value));
+      }
+      return array;
+    }
+
+    private struct Entry {
+      public JObject TargetAlgorithm { get; set; }
+
+      public Algorithm SourceAlgorithm { get; set; }
+    }
+
+    private static Algorithm ParseAlgorithm(JToken jsonAlgorithm) {
+      var algorithm = new Algorithm();
+
+      foreach (JObject param in jsonAlgorithm["AlgorithmParameters"]) {
+        Parameter parameter = CreateParameter(param);
+        algorithm.Parameters.Items.Add(parameter);
+      }
+
+      var problemParams = jsonAlgorithm["ProblemParameters"];
+      if (problemParams != null) {
+        algorithm.Problem = new Problem();
+        foreach (JObject param in problemParams) {
+          Parameter parameter = CreateParameter(param);
+          algorithm.Problem.Parameters.Items.Add(parameter);
+        }
+      }
+      return algorithm;
+    }
+    #endregion
+
+
+    #region public methods
+
+
+    public static JObject ConvertExperimentToJson(Experiment experiment) {
+      var exp = new JObject();
+      exp["title"] = experiment.Name;
+      exp["children"] = new JArray();
+      exp["nodeId"] = experiment.Id;
+      exp["isExperiment"] = true;
+
+      var stack = new Stack<Entry>();
+      foreach (var algo in experiment.Algorithm)
+        stack.Push(new Entry() { TargetAlgorithm = exp, SourceAlgorithm = algo });
+
+      while (stack.Count > 0) {
+        var entry = stack.Pop();
+        var algorithm = ConvertAlgorithmToJson(entry.SourceAlgorithm);
+        (entry.TargetAlgorithm["children"] as JArray).Add(algorithm);
+
+        if (entry.SourceAlgorithm.ChildAlgorithms.Count > 0) {
+          // push children
+          foreach (var child in entry.SourceAlgorithm.ChildAlgorithms) {
+            stack.Push(new Entry() { TargetAlgorithm = algorithm, SourceAlgorithm = child });
+          }
+        }
+
+      }
+      return exp;
+    }
+
+    public static JArray ConvertExperimentsToJson(IEnumerable<Experiment> experiments) {
+      var jarray = new JArray();
+      foreach (var exp in experiments)
+        jarray.Add(ConvertExperimentToJson(exp));
+      return jarray;
+    }
+
+    public static JArray ConvertAlgorithmsToJson(IEnumerable<Algorithm> algorithms) {
+      var jarray = new JArray();
+      foreach (var algo in algorithms)
+        jarray.Add(ConvertAlgorithmToJson(algo));
+      return jarray;
+    }
+
+
+    public static JArray ConvertScenariosToJson(IEnumerable<OptimizationScenario> scenarios) {
+      var jarray = new JArray();
+      foreach (var scen in scenarios)
+        jarray.Add(ConvertScenarioToJson(scen));
+      return jarray;
+    }
+
+    public static JObject ConvertScenarioToJson(OptimizationScenario scenario) {
+      var exp = new JObject();
+      exp["title"] = scenario.Id;
+      exp["children"] = new JArray();
+      exp["nodeId"] = scenario.Id;
+      exp["isExperiment"] = false;
+
+      var stack = new Stack<Entry>();
+      var baseAlgorithm = ConvertAlgorithmToJson(scenario.FirstAlgorithm);
+      exp["data"] = baseAlgorithm["data"];
+      if (scenario.FirstAlgorithm.ChildAlgorithms.Count > 0) {
+        foreach (var child in scenario.FirstAlgorithm.ChildAlgorithms)
+          stack.Push(new Entry() { TargetAlgorithm = exp, SourceAlgorithm = child});
+      }
+
+      while (stack.Count > 0) {
+        var entry = stack.Pop();
+        var algorithm = ConvertAlgorithmToJson(entry.SourceAlgorithm);
+        (entry.TargetAlgorithm["children"] as JArray).Add(algorithm);
+
+        if (entry.SourceAlgorithm.ChildAlgorithms.Count > 0) {
+          // push children
+          foreach (var child in entry.SourceAlgorithm.ChildAlgorithms) {
+            stack.Push(new Entry() { TargetAlgorithm = algorithm, SourceAlgorithm = child });
+          }
+        }
+
+      }
+      return exp;
+    }
+
+    public static JObject ConvertAlgorithmToJson(Algorithm algorithm) {
+      var jalgo = new JObject();
+      jalgo["title"] = algorithm.Name;
+      jalgo["nodeId"] = algorithm.Id;
+      var jalgoData = new JObject();
+      jalgo["data"] = jalgoData;
+      jalgo["isExperiment"] = algorithm.IsExperiment;
+      jalgoData["AlgorithmParameters"] = ConvertParametersToJson(algorithm.Parameters.Items);
+      if (algorithm.Problem != null && algorithm.Problem.Parameters != null)
+        jalgoData["ProblemParameters"] = ConvertParametersToJson(algorithm.Problem.Parameters.Items);
+
+      jalgo["children"] = new JArray();
+      return jalgo;
+    }
+
+    public static Experiment ConvertJsonToExperiment(string json) {
       var experiment = new Experiment();
       var jsonExperiment = JObject.Parse(json);
-      experiment.Name = (string)jsonExperiment["name"];
+      experiment.Name = (string)jsonExperiment["title"];
+      experiment.Id = (string)jsonExperiment["nodeId"];      
       var stack = new Stack<StackEntry>();
       var root = new Algorithm();
 
-      if ((bool)jsonExperiment["run"]) {
+      if (jsonExperiment["run"] != null && (bool)jsonExperiment["run"]) {
         experiment.JobDetails = new JobExecutionDetails() {
-           Group = (string)jsonExperiment["group"],
-           Repititions = (int)jsonExperiment["repititions"]
+          Group = (string)jsonExperiment["group"],
+          Repititions = (int)jsonExperiment["repititions"]
         };
       }
 
-      foreach (var algo in jsonExperiment["algorithms"]["children"]) {
-        stack.Push(new StackEntry(){ Parent = root, Child = algo });
-      }
+      // ignore experiment node, skip to its children
+      if (jsonExperiment["experiment"] != null)
+        foreach (var algo in jsonExperiment["experiment"]["children"]) {
+          stack.Push(new StackEntry() { Parent = root, Child = algo });
+        }
+
+      if (jsonExperiment["children"] != null)
+        foreach (var algo in jsonExperiment["children"]) {
+          stack.Push(new StackEntry() { Parent = root, Child = algo });
+        }
 
       while (stack.Count > 0) {
         var entry = stack.Pop();
         var data = entry.Child["data"];
-        var currentAlgo = data == null ? new Algorithm() : ParseAlgorithm(entry.Child["data"]);
-        currentAlgo.Name = (string)entry.Child["name"];
+        var currentAlgo = data == null || !data.HasValues ? new Algorithm() : ParseAlgorithm(entry.Child["data"]);
+        currentAlgo.Name = (string)entry.Child["title"];
+        currentAlgo.Id = (string)entry.Child["nodeId"];
+        currentAlgo.IsExperiment = (bool)entry.Child["isExperiment"];
         entry.Parent.ChildAlgorithms.Add(currentAlgo);
         // push children on stack (inverse order to preserve ordering)
         var cnt = entry.Child["children"].Count();
-        for (var i=0; i < cnt; i++) {
+        for (var i = 0; i < cnt; i++) {
           stack.Push(new StackEntry() { Parent = currentAlgo, Child = entry.Child["children"][cnt - 1 - i] });
         }
@@ -154 +231 @@
       return experiment;
     }
+    #endregion
   }
 }