cache

GsaGH/Parameters/5_Results/Caches/AnalysisCaseNodeDisplacementCache.cs

@@ -9,31 +9,26 @@ namespace GsaGH.Parameters.Results {
   public class AnalysisCaseNodeDisplacementCache : INodeResultCache<IDisplacement> {
     public IApiResult ApiResult { get; set; }
 
-    // API Node results (will not be needed after GSA-7517)
-    internal Dictionary<string, ReadOnlyDictionary<int, NodeResult>> AnalysisCaseNodeResults { get; set; }
-      = new Dictionary<string, ReadOnlyDictionary<int, NodeResult>>();
-
-    public IDictionary<string, IResultSubset<IDisplacement>> Cache { get; set; }
-      = new Dictionary<string, IResultSubset<IDisplacement>>();
+    public ConcurrentDictionary<int, ICollection<IDisplacement>> Cache { get; }
+      = new ConcurrentDictionary<int, ICollection<IDisplacement>>();
 
     internal AnalysisCaseNodeDisplacementCache(AnalysisCaseResult result) {
       ApiResult = new AnalysisCaseApiResult(result);
     }
 
-    public IResultSubset<IDisplacement> ResultSubset(string nodelist) {
-      if (nodelist.ToLower() == "all" || nodelist == string.Empty) {
-        nodelist = "All";
-      }
-
-      if (!Cache.ContainsKey(nodelist)) {
-        if (!AnalysisCaseNodeResults.ContainsKey(nodelist)) {
-          AnalysisCaseNodeResults.Add(nodelist, ((AnalysisCaseResult)ApiResult.Result).NodeResults(nodelist));
-        }
-
-        Cache.Add(nodelist, new GsaNodeDisplacements(AnalysisCaseNodeResults[nodelist]));
+    public IResultSubset<IDisplacement> ResultSubset(ICollection<int> nodeIds) {
+      ConcurrentBag<int> missingIds = Cache.GetMissingKeys(nodeIds);
+      if (missingIds.Count > 0) {
+        string nodelist = string.Join(" ", missingIds);
+        ReadOnlyDictionary<int, NodeResult> apiAnalysisCaseResults = 
+          ((AnalysisCaseResult)ApiResult.Result).NodeResults(nodelist);
+        Parallel.ForEach(missingIds, nodeId => {
+          var res = new GsaDisplacementQuantity(apiAnalysisCaseResults[nodeId].Displacement);
+          Cache.TryAdd(nodeId, new Collection<IDisplacement>() { res });
+        });
       }
 
-      return Cache[nodelist];
+      return new GsaNodeDisplacements(Cache.GetSubset(nodeIds));
     }
   }
 }

GsaGH/Parameters/5_Results/Caches/CacheUtility.cs

@@ -0,0 +1,28 @@
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Threading.Tasks;
+
+namespace GsaGH.Parameters.Results {
+  public static class CacheUtility {
+    public static ConcurrentBag<int> GetMissingKeys<T>(
+      this IDictionary<int, T> existing, ICollection<int> newKeys) {
+      var missingIds = new ConcurrentBag<int>();
+      Parallel.ForEach(newKeys, key => {
+        if (!existing.ContainsKey(key)) {
+          missingIds.Add(key);
+        }
+      });
+
+      return missingIds;
+    }
+
+    public static ConcurrentDictionary<int, T> GetSubset<T>(
+      this IDictionary<int, T> dictionary, ICollection<int> keys) {
+      var subset = new ConcurrentDictionary<int, T>();
+      Parallel.ForEach(keys, key => subset.TryAdd(key, dictionary[key]));
+      return subset;
+    }
+  }
+}

GsaGH/Parameters/5_Results/Caches/CombinationCaseNodeDisplacementCache.cs

@@ -9,32 +9,30 @@ namespace GsaGH.Parameters.Results {
   public class CombinationCaseNodeDisplacementCache : INodeResultCache<IDisplacement> {
     public IApiResult ApiResult { get; set; }
 
-    // API Node results (will not be needed after GSA-7517)
-    internal Dictionary<string, ReadOnlyDictionary<int, ReadOnlyCollection<NodeResult>>>
-      CombinationCaseNodeResults { get; set; }
-      = new Dictionary<string, ReadOnlyDictionary<int, ReadOnlyCollection<NodeResult>>>();
-
-    public IDictionary<string, IResultSubset<IDisplacement>> Cache { get; set; }
-      = new Dictionary<string, IResultSubset<IDisplacement>>();
+    public ConcurrentDictionary<int, ICollection<IDisplacement>> Cache { get; set; }
+      = new ConcurrentDictionary<int, ICollection<IDisplacement>>();
 
     internal CombinationCaseNodeDisplacementCache(CombinationCaseResult result) {
       ApiResult = new CombinationCaseApiResult(result);
     }
 
-    public IResultSubset<IDisplacement> ResultSubset(string nodelist) {
-      if (nodelist.ToLower() == "all" || nodelist == string.Empty) {
-        nodelist = "All";
-      }
-
-      if (!Cache.ContainsKey(nodelist)) {
-        if (!CombinationCaseNodeResults.ContainsKey(nodelist)) {
-          CombinationCaseNodeResults.Add(nodelist, ((CombinationCaseResult)ApiResult.Result).NodeResults(nodelist));
-        }
-
-        Cache.Add(nodelist, new GsaNodeDisplacements(CombinationCaseNodeResults[nodelist]));
+    public IResultSubset<IDisplacement> ResultSubset(ICollection<int> nodeIds) {
+      ConcurrentBag<int> missingIds = Cache.GetMissingKeys(nodeIds);
+      if (missingIds.Count > 0) {
+        string nodelist = string.Join(" ", missingIds);
+        ReadOnlyDictionary<int, ReadOnlyCollection<NodeResult>> apiCombinationCaseResults =
+          ((CombinationCaseResult)ApiResult.Result).NodeResults(nodelist);
+        Parallel.ForEach(missingIds, nodeId => {
+          var permutationResults = new Collection<IDisplacement>();
+          foreach (NodeResult permutationResult in apiCombinationCaseResults[nodeId]) {
+            permutationResults.Add(new GsaDisplacementQuantity(permutationResult.Displacement));
+          }
+
+          Cache.TryAdd(nodeId, permutationResults);
+        });
       }
 
-      return Cache[nodelist];
+      return new GsaNodeDisplacements(Cache.GetSubset(nodeIds));
     }
   }
 }

GsaGH/Parameters/5_Results/Caches/INodeResultCache.cs

@@ -1,9 +1,10 @@
-using System.Collections.Generic;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
 
 namespace GsaGH.Parameters.Results {
   public interface INodeResultCache<T> where T : IResultQuantitySet {
     public IApiResult ApiResult { get; set; }
-    public IDictionary<string, IResultSubset<T>> Cache { get;}
-    public IResultSubset<T> ResultSubset(string list);
+    public ConcurrentDictionary<int, ICollection<T>> Cache { get; }
+    public IResultSubset<T> ResultSubset(ICollection<int> list);
   }
 }

GsaGH/Parameters/5_Results/Quantities/GsaDisplacementQuantity.cs

@@ -33,11 +33,11 @@ internal GsaDisplacementQuantity(Double6 result) {
       X = new Length(result.X, LengthUnit.Meter);
       Y = new Length(result.Y, LengthUnit.Meter);
       Z = new Length(result.Z, LengthUnit.Meter);
-      Xyz = ResultUtility.PythagoreanQuadruple(X, Y, Z);
+      Xyz = QuantityUtility.PythagoreanQuadruple(X, Y, Z);
       Xx = CreateAngle(result.XX);
       Yy = CreateAngle(result.YY);
       Zz = CreateAngle(result.ZZ);
-      Xxyyzz = ResultUtility.PythagoreanQuadruple(Xx, Yy, Zz);
+      Xxyyzz = QuantityUtility.PythagoreanQuadruple(Xx, Yy, Zz);
     }
 
     private Angle CreateAngle(double val) {

GsaGH/Parameters/5_Results/Quantities/ResultUtility.cs → GsaGH/Parameters/5_Results/Quantities/QuantityUtility.cs

@@ -7,8 +7,8 @@
 using System.Linq;
 
 namespace GsaGH.Parameters.Results {
-  public static class ResultUtility {
-    public static IDisplacement GetMax(this ICollection<Collection<IDisplacement>> c) {
+  public static class QuantityUtility {
+    public static IDisplacement GetMax(this ICollection<ICollection<IDisplacement>> c) {
       return new GsaDisplacementQuantity(
         c.Select(c => c.Select(p => p.X).Max()).Max(),
         c.Select(c => c.Select(p => p.Y).Max()).Max(),
@@ -20,7 +20,7 @@ public static IDisplacement GetMax(this ICollection<Collection<IDisplacement>> c
         c.Select(c => c.Select(p => p.Xxyyzz).Max()).Max());
     }
 
-    public static IDisplacement GetMin(this ICollection<Collection<IDisplacement>> c) {
+    public static IDisplacement GetMin(this ICollection<ICollection<IDisplacement>> c) {
       return new GsaDisplacementQuantity(
         c.Select(c => c.Select(p => p.X).Min()).Min(),
         c.Select(c => c.Select(p => p.Y).Min()).Min(),

GsaGH/Parameters/5_Results/ResultSubsets/GsaNodeDisplacements.cs

@@ -12,34 +12,14 @@ public class GsaNodeDisplacements : IResultSubset<IDisplacement> {
     public List<int> Ids => Results.Keys.OrderBy(x => x).ToList();
 
     /// <summary>
-    ///   Combination Case Node Displacement Result VALUES Dictionary
-    ///   Append to this dictionary to chache results
     ///   key = nodeId
     ///   value = Collection of permutations(permutationsResults) ei Collection will have 1 item in case of AnalysisCase
     /// </summary>
-    public ConcurrentDictionary<int, Collection<IDisplacement>> Results { get; }
-      = new ConcurrentDictionary<int, Collection<IDisplacement>>();
+    public ConcurrentDictionary<int, ICollection<IDisplacement>> Results { get; }
+      = new ConcurrentDictionary<int, ICollection<IDisplacement>>();
 
-    internal GsaNodeDisplacements(ReadOnlyDictionary<int, NodeResult> apiAnalysisCaseResults) {
-      Parallel.ForEach(apiAnalysisCaseResults.Keys, nodeId => {
-        var res = new GsaDisplacementQuantity(apiAnalysisCaseResults[nodeId].Displacement);
-        Results.TryAdd(nodeId, new Collection<IDisplacement>() { res });
-      });
-
-      Max = Results.Values.GetMax();
-      Min = Results.Values.GetMin();
-    }
-
-    internal GsaNodeDisplacements(ReadOnlyDictionary<int, ReadOnlyCollection<NodeResult>> apiCombinationCaseResults) {
-      Parallel.ForEach(apiCombinationCaseResults.Keys, nodeId => {
-        var permutationResults = new Collection<IDisplacement>();
-        foreach (NodeResult permutationResult in apiCombinationCaseResults[nodeId]) {
-          permutationResults.Add(new GsaDisplacementQuantity(permutationResult.Displacement));
-        }
-
-        Results.TryAdd(nodeId, permutationResults);
-      });
-
+    internal GsaNodeDisplacements(ConcurrentDictionary<int, ICollection<IDisplacement>> results) {
+      Results = results;
       Max = Results.Values.GetMax();
       Min = Results.Values.GetMin();
     }

GsaGH/Parameters/5_Results/ResultSubsets/IResultSubset.cs

@@ -1,12 +1,11 @@
 using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 
 namespace GsaGH.Parameters.Results {
   public interface IResultSubset<T> where T : IResultQuantitySet {
     public T Max { get; }
     public T Min { get; }
     public List<int> Ids { get; }
-    public ConcurrentDictionary<int, Collection<T>> Results { get; }
+    public ConcurrentDictionary<int, ICollection<T>> Results { get; }
   } 
 }

GsaGH/Parameters/5_Results/Results/GsaResult2.cs

@@ -30,8 +30,6 @@ internal Dictionary<string, ReadOnlyDictionary<int, ReadOnlyCollection<NodeResul
     public List<int> SelectedPermutationIds { get; set; }
     public CaseType CaseType { get; set; }
 
-    public GsaResult2() { }
-
     internal GsaResult2(GsaModel model, AnalysisCaseResult result, int caseId) {
       Model = model;
       AnalysisCaseResult = result;
@@ -72,7 +70,13 @@ public override string ToString() {
     }
 
     internal GsaNodeDisplacements NodeDisplacementValues(string nodelist) {
-      return (GsaNodeDisplacements)NodeDisplacements.ResultSubset(nodelist);
+      var entityList = new EntityList() {
+        Definition = nodelist,
+        Type = GsaAPI.EntityType.Node,
+        Name = "tmp"
+      };
+      ReadOnlyCollection<int> nodeIds = Model.Model.ExpandList(entityList);
+      return (GsaNodeDisplacements)NodeDisplacements.ResultSubset(nodeIds);
     }
   }
 }

GsaGHTests/1_BaseParameters/5_Results/Collections/GsaNodeDisplacementsTests.cs

@@ -160,7 +160,7 @@ public void GsaNodeDisplacementsValuesFromAnalysisCaseTest(GsaNodeDisplacementCo
       // Assert result values
       int i = 0;
       foreach (int id in resultSet.Ids) {
-        Collection<IDisplacement> displacementQuantity = resultSet.Results[id];
+        var displacementQuantity = (Collection<IDisplacement>)resultSet.Results[id];
 
         // for analysis case results we expect only one value in the collection
         Assert.Single(displacementQuantity);
@@ -191,7 +191,7 @@ public void GsaNodeDisplacementsValuesFromCombinationCaseTest(GsaNodeDisplacemen
       // Assert result values
       int i = 0;
       foreach (int id in resultSet.Ids) {
-        Collection<IDisplacement> displacementQuantity = resultSet.Results[id];
+        var displacementQuantity = (Collection<IDisplacement>)resultSet.Results[id];
 
         // for C4 case results we expect two permutations in the collection
         Assert.Equal(2, displacementQuantity.Count);

GsaGHTests/1_BaseParameters/5_Results/Quantities/ResultUtilityTests.cs

@@ -12,7 +12,7 @@ public void PythagoreanQuadrupleTest(double a, double b, double c, Enum unit) {
       IQuantity x = Quantity.From(a, unit);
       IQuantity y = Quantity.From(b, unit);
       IQuantity z = Quantity.From(c, unit);
-      IQuantity quantity = ResultUtility.PythagoreanQuadruple(x, y, z);
+      IQuantity quantity = QuantityUtility.PythagoreanQuadruple(x, y, z);
 
       double pyth = Math.Sqrt((a * a) + (b * b) + (c * c));
       IQuantity expected = Quantity.From(pyth, unit);