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

Timestamp:

02/19/13 08:46:01 (12 years ago)

Author:

fschoepp

Message:

#1888:

• Experiments will be saved as JSON elements within the blob store.
• Added simple model and JSON converters.
• Backend stores and runs experiments.
• Updated interfaces to save/read experiments.
• Added a binding to automatically map incoming JSON ajax requests to experiment models.
• Added the javascript DatatypeMapper to map parameter inputs to the right html elements and vice versa.
• Added smartwizard to generate Wizards for creating new experiments (New.cshtml).

File:

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

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

@@ -5 +5 @@
 using HeuristicLab.Services.Optimization.ControllerService.Model;
 using Newtonsoft.Json.Linq;
+using Newtonsoft.Json;
 
 namespace HeuristicLab.Services.Optimization.ControllerService.Parsers {
@@ -10 +11 @@
 
     public static Algorithm Convert(string json) {
+      var o = JObject.Parse(json);
+      return ParseAlgorithm(o);      
+    }
+
+    private static Algorithm ParseAlgorithm(JToken obj) {
       var algorithm = new Algorithm();
-      var o = JObject.Parse(json);
-      foreach (JProperty param in o["Algorithm Parameters"]) {
+
+      foreach (JProperty param in obj["Algorithm Parameters"]) {
         Parameter parameter = CreateParameter(param);
         algorithm.Parameters.Items.Add(parameter);
       }
 
-      var problemParams = o["Problem Parameters"];
-      // TODO: Store problem parameters
+      var problemParams = obj["Problem Parameters"];
       if (problemParams != null) {
         algorithm.Problem = new Problem();
@@ -69 +74 @@
         case JTokenType.String:
           return new Parameter() { Type = ParameterType.Type, Value = new TypeValue() { Name = property.Name, Value = (string)property.Value } };                  
+        case JTokenType.Array:
+          var arr = (JArray)token;
+          // its a matrix
+          if (arr[0].Type == JTokenType.Array) {
+            return CreateMatrixParameter(property.Name, arr);
+          }
+          return CreateVectorParameter(property.Name, arr);
         default:
           throw new Exception("Unhandled datatype: " + property.Type);
       }
     }
+
+    private static Parameter CreateMatrixParameter(string name, JArray arr) {
+      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>();  
+      }
+      return new Parameter { Type = ParameterType.DecimalMatrix, Value = new DecimalMatrix() { Name = name, Value = entries } };
+    }
+
+    private static Parameter CreateVectorParameter(string name, JArray arr) {
+      double[] entries = (from d in arr select (double)d).ToArray<double>();
+      return new Parameter { Type = ParameterType.DecimalVector, Value = new DecimalVector() { Name = name, Value = entries } };
+    }
+
+    public static string ConvertJson(Algorithm algorithm) {
+      return JsonConvert.SerializeObject(algorithm);
+    }
+
+    
+    private class StackEntry {
+      public Algorithm Parent { get; set; }
+      public JToken Child { get; set; }
+    }
+
+    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) {
+      var experiment = new Experiment();
+      var jsonExperiment = JObject.Parse(json);
+      experiment.Name = (string)jsonExperiment["name"];
+      var stack = new Stack<StackEntry>();
+      var root = new Algorithm();
+
+      if ((bool)jsonExperiment["run"]) {
+        experiment.JobDetails = new JobExecutionDetails() {
+           Group = (string)jsonExperiment["group"],
+           Repititions = (int)jsonExperiment["repititions"]
+        };
+      }
+
+      foreach (var algo in jsonExperiment["algorithms"]["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"];
+        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++) {
+          stack.Push(new StackEntry() { Parent = currentAlgo, Child = entry.Child["children"][cnt - 1 - i] });
+        }
+      }
+
+      foreach (var algo in root.ChildAlgorithms) {
+        experiment.Algorithm.Add(algo);
+      }
+
+      return experiment;
+    }
   }
 }