Index: /branches/2825-NSGA3/HeuristicLab.Algorithms.NSGA3/3.3/NSGA3.cs
===================================================================
--- /branches/2825-NSGA3/HeuristicLab.Algorithms.NSGA3/3.3/NSGA3.cs	(revision 17616)
+++ /branches/2825-NSGA3/HeuristicLab.Algorithms.NSGA3/3.3/NSGA3.cs	(revision 17617)
@@ -52,10 +52,4 @@
         private List<Solution> solutions;
 
-        [Storable]
-        private List<List<Solution>> fronts;
-
-        [Storable]
-        private List<ReferencePoint> referencePoints;
-
         #endregion Storable fields
 
@@ -134,4 +128,8 @@
         public BoolValue DominateOnEqualQualities => DominateOnEqualQualitiesParameter.Value;
 
+        public List<List<Solution>> Fronts { get; private set; }
+
+        public List<ReferencePoint> ReferencePoints { get; private set; }
+
         #endregion Properties
 
@@ -151,4 +149,6 @@
 
         #endregion ResultsProperties
+
+        #region Constructors
 
         public NSGA3() : base()
@@ -178,10 +178,12 @@
         }
 
-        #region Overriden Methods
-
         public override IDeepCloneable Clone(Cloner cloner)
         {
             return new NSGA3(this, cloner);
         }
+
+        #endregion Constructors
+
+        #region Initialization
 
         protected override void Initialize(CancellationToken cancellationToken)
@@ -195,15 +197,4 @@
         }
 
-        protected override void Run(CancellationToken cancellationToken)
-        {
-            referencePoints = new List<ReferencePoint>(); // todo: use existing list of reference points
-            for (int iteration = 0; iteration < MaximumGenerations.Value; iteration++)
-                ToNextGeneration();
-        }
-
-        #endregion Overriden Methods
-
-        #region Private Methods
-
         private void InitFields()
         {
@@ -235,13 +226,28 @@
             // Generate reference points and add them to results
             int nDiv = 5; // todo: figure out the correct number of divisions
-            referencePoints = ReferencePoint.GenerateReferencePoints(Problem.Encoding.Length, nDiv);
-            ResultsGeneratedReferencePoints = Utility.ConvertToDoubleMatrix(referencePoints);
+            ReferencePoints = ReferencePoint.GenerateReferencePoints(Problem.Encoding.Length, nDiv);
+            ResultsGeneratedReferencePoints = Utility.ConvertToDoubleMatrix(ReferencePoints);
         }
 
         private void InitResults()
         {
-            Results.Add(new Result(GeneratedReferencePointsResultName, "The initially generated reference points", Utility.ConvertToDoubleMatrix(referencePoints)));
+            Results.Add(new Result(GeneratedReferencePointsResultName, "The initially generated reference points", Utility.ConvertToDoubleMatrix(ReferencePoints)));
             Results.Add(new Result(CurrentFrontResultName, "The Pareto Front", new DoubleMatrix()));
         }
+
+        #endregion Initialization
+
+        #region Overriden Methods
+
+        protected override void Run(CancellationToken cancellationToken)
+        {
+            ReferencePoints = new List<ReferencePoint>(); // todo: use existing list of reference points
+            for (int iteration = 0; iteration < MaximumGenerations.Value; iteration++)
+                ToNextGeneration();
+        }
+
+        #endregion Overriden Methods
+
+        #region Private Methods
 
         private void Analyze()
@@ -278,12 +284,12 @@
             // compute the pareto fronts using the DominationCalculator and discard the qualities
             // part in the inner tuples
-            fronts = DominationCalculator<Solution>.CalculateAllParetoFronts(rt.ToArray(), qualities, Problem.Maximization, out int[] rank, true)
+            Fronts = DominationCalculator<Solution>.CalculateAllParetoFronts(rt.ToArray(), qualities, Problem.Maximization, out int[] rank, true)
                 .Select(list => new List<Solution>(list.Select(pair => pair.Item1))).ToList();
 
             int i = 0;
             List<Solution> lf = null; // last front to be included
-            while (i < fronts.Count && st.Count < PopulationSize.Value)
-            {
-                lf = fronts[i];
+            while (i < Fronts.Count && st.Count < PopulationSize.Value)
+            {
+                lf = Fronts[i];
                 st = Utility.Concat(st, lf);
                 i++;
@@ -297,5 +303,5 @@
                 nextGeneration = new List<Solution>();
                 for (int f = 0; f < l; f++)
-                    nextGeneration = Utility.Concat(nextGeneration, fronts[f]);
+                    nextGeneration = Utility.Concat(nextGeneration, Fronts[f]);
                 Normalize(st);
                 Associate();
@@ -328,5 +334,5 @@
                 for (int i = 0; i < Problem.Encoding.Length; i++) weights[i] = EPSILON;
                 weights[j] = 1;
-                Func<Solution, double> func = s => ASF(s.Fitness, weights);
+                double func(Solution s) => ASF(s.Fitness, weights);
                 extremePoints[j] = Utility.ArgMin(func, solutions);
             }
@@ -344,7 +350,7 @@
         private void NormalizeObjectives(List<double> intercepts, double[] idealPoint)
         {
-            for (int f = 0; f < fronts.Count; f++)
-            {
-                foreach (var solution in fronts[f])
+            for (int f = 0; f < Fronts.Count; f++)
+            {
+                foreach (var solution in Fronts[f])
                 {
                     for (int i = 0; i < Problem.Encoding.Length; i++)
@@ -365,11 +371,11 @@
         private void Associate()
         {
-            for (int f = 0; f < fronts.Count; f++)
-            {
-                foreach (var solution in fronts[f])
+            for (int f = 0; f < Fronts.Count; f++)
+            {
+                foreach (var solution in Fronts[f])
                 {
                     // find reference point for which the perpendicular distance to the current
                     // solution is the lowest
-                    var rpAndDist = Utility.MinArgMin(rp => GetPerpendicularDistance(rp.Values, solution.Fitness), referencePoints);
+                    var rpAndDist = Utility.MinArgMin(rp => GetPerpendicularDistance(rp.Values, solution.Fitness), ReferencePoints);
 
                     //// todo: use ArgMin here
@@ -385,5 +391,5 @@
                     //    }
                     //}
-                    if (f + 1 != fronts.Count)
+                    if (f + 1 != Fronts.Count)
                     {
                         // Todo: Add member for reference point on index min_rp
@@ -422,5 +428,5 @@
             List<int> dimensions = new List<int>();
             for (int i = 0; i < Problem.Encoding.Length; i++) dimensions.Add(i);
-            Func<int, double> f = dim => x[dim] / weight[dim];
+            double f(int dim) => x[dim] / weight[dim];
             return Utility.Max(f, dimensions);
         }
Index: /branches/2825-NSGA3/HeuristicLab.Algorithms.NSGA3/3.3/ReferencePoint.cs
===================================================================
--- /branches/2825-NSGA3/HeuristicLab.Algorithms.NSGA3/3.3/ReferencePoint.cs	(revision 17616)
+++ /branches/2825-NSGA3/HeuristicLab.Algorithms.NSGA3/3.3/ReferencePoint.cs	(revision 17617)
@@ -1,5 +1,3 @@
 ﻿using System.Collections.Generic;
-using HEAL.Attic;
-using HeuristicLab.Common;
 
 namespace HeuristicLab.Algorithms.NSGA3
@@ -11,18 +9,14 @@
      */
 
-    [StorableType("96DCBD85-7C8B-4546-B6F5-FB4AE0DF7158")]
-    internal class ReferencePoint : IDeepCloneable
+    public class ReferencePoint
     {
-        #region Storable Properties
+        #region Properties
 
         public double[] Values { get; }
-
-        #endregion Storable Properties
-
-        #region Properties
-
         public int NumberOfDimensions => Values.Length;
 
         #endregion Properties
+
+        #region Constructors
 
         public ReferencePoint(int numberOfDimensions)
@@ -38,14 +32,5 @@
         }
 
-        public IDeepCloneable Clone(Cloner cloner)
-        {
-            // no cloner is required to copy a Reference Point
-            return new ReferencePoint(this);
-        }
-
-        public object Clone()
-        {
-            return new Cloner().Clone(this);
-        }
+        #endregion Constructors
 
         // todo: use this (for optimization)
