Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/DikesAssessmentRegional/RWScenariosCalculation.cs
===================================================================
diff -u -r1062 -r1065
--- DamEngine/trunk/src/Deltares.DamEngine.Calculators/DikesAssessmentRegional/RWScenariosCalculation.cs	(.../RWScenariosCalculation.cs)	(revision 1062)
+++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/DikesAssessmentRegional/RWScenariosCalculation.cs	(.../RWScenariosCalculation.cs)	(revision 1065)
@@ -24,10 +24,9 @@
 using System.Diagnostics;
 using System.Linq;
 using System.Text.RegularExpressions;
-using Deltares.DamEngine.Calculators.Dikes_Assessment_Regional;
 using Deltares.DamEngine.Data.General;
 using Deltares.DamEngine.Data.Geotechnics;
-using Deltares.DamEngine.Data.RWScenarios;
+using Deltares.DamEngine.Data.RegionalAssessmentResults;
 using Deltares.DamEngine.Data.Standard.Calculation;
 using Deltares.DamEngine.Data.Standard.Language;
 using Deltares.DamEngine.Data.Standard.Logging;
@@ -52,7 +51,7 @@
         private string mstabExePath = @".\DGeoStability.exe";
         private int maxCalculationCores = 255;
 
-        private Dictionary<ICalculation, RWResult> runningJobs = new Dictionary<ICalculation, RWResult>();
+        private Dictionary<ICalculation, RegionalResult> runningJobs = new Dictionary<ICalculation, RegionalResult>();
         private bool isSkipStabilityCalculation = false;
         
         public PipingModelType PipingModelType { get; set; }
@@ -132,7 +131,7 @@
             try
             {
 
-                List<RWScenarioProfileResult> tasks = this.FillQueue();
+                List<RegionalScenarioProfileResult> tasks = this.FillQueue();
 
                 General.Parallel.Run(tasks, this.RunTask, this.progressDelegate, this.MaxCalculationCores);
                 this.FillResults(tasks);
@@ -176,9 +175,9 @@
             set { maxCalculationCores = value; }
         }
 
-        private List<RWScenarioProfileResult> FillQueue()
+        private List<RegionalScenarioProfileResult> FillQueue()
         {
-            List<RWScenarioProfileResult> tasks = new List<RWScenarioProfileResult>();
+            List<RegionalScenarioProfileResult> tasks = new List<RegionalScenarioProfileResult>();
 
             this.evaluationJob.FailedEvaluatedLocations = new List<Location>();
             foreach (Location location in this.evaluationJob.Locations)
@@ -223,7 +222,7 @@
                             {
 
                                 SoilProfile soilProfile = soilGeometryProbability.SoilProfile1D;
-                                IList<RWScenarioProfileResult> rwScenarios = null;
+                                IList<RegionalScenarioProfileResult> rwScenarios = null;
                                 try
                                 {
                                     rwScenarios = this.GetRWScenarios(location, soilGeometryProbability);
@@ -242,7 +241,7 @@
                                 }
                                 if (rwScenarios != null)
                                 {
-                                    foreach (RWScenarioProfileResult job in rwScenarios)
+                                    foreach (RegionalScenarioProfileResult job in rwScenarios)
                                     {
                                         tasks.Add(job);
                                     }
@@ -256,17 +255,17 @@
             return tasks;
         }
 
-        private IList<RWScenarioProfileResult> GetRWScenarios(Location location, SoilGeometryProbability soilGeometryProbability)
+        private IList<RegionalScenarioProfileResult> GetRWScenarios(Location location, SoilGeometryProbability soilGeometryProbability)
         {
-            RWScenarioSelector selector = new RWScenarioSelector();
+            RegionalScenarioSelector selector = new RegionalScenarioSelector();
             selector.PipingModelType = PipingModelType;
             selector.MStabParameters = MStabParameters;
             return selector.GetScenarios(location, soilGeometryProbability);
         }
 
         private void RunTask(object task)
         {
-            RWScenarioProfileResult job = (RWScenarioProfileResult)task;
+            var job = (RegionalScenarioProfileResult)task;
 
             try
             {
@@ -290,7 +289,7 @@
         /// Select which job processor to use, depending on failuremechanism
         /// </summary>
         /// <param name="job"></param>
-        private void ProcessJob(RWScenarioProfileResult job)
+        private void ProcessJob(RegionalScenarioProfileResult job)
         {
             Debug.WriteLine(String.Format("Job {0}, location {1}, Scenario {2}", job.FailureMechanismType.ToString(), job.LocationName, job.ScenarioType.ToString()));
             switch (job.FailureMechanismType)
@@ -310,7 +309,7 @@
         /// Process a job for failuremechanism Piping
         /// </summary>
         /// <param name="job"></param>
-        private void ProcessJobPiping(RWScenarioProfileResult job)
+        private void ProcessJobPiping(RegionalScenarioProfileResult job)
         {
 //            if (job.Location.ModelFactors.UpliftCriterionPiping.HasValue)
 //            {
@@ -355,7 +354,7 @@
 
         }
 
-        private string GetCalculationNameForPipingCalculator(RWScenarioProfileResult job)
+        private string GetCalculationNameForPipingCalculator(RegionalScenarioProfileResult job)
         {
             string calculationName;
             switch (job.PipingModelOption)
@@ -408,7 +407,7 @@
         /// Process a job for failuremechanism Stability
         /// </summary>
         /// <param name="job"></param>
-        private void ProcessJobStability(RWScenarioProfileResult job)
+        private void ProcessJobStability(RegionalScenarioProfileResult job)
         {
 //            StabilityCalculation calculator = new StabilityCalculation();
 
@@ -439,7 +438,7 @@
 
 //                job.CalculationResult = calculator.GetResults(ref results);
                 //XmlDeserializer deserializer = new XmlDeserializer();
-//                RWResult result = (RWResult)deserializer.XmlDeserializeFromString(results, typeof(RWResult));
+//                RegionalResult result = (RegionalResult)deserializer.XmlDeserializeFromString(results, typeof(RegionalResult));
 
 //                job.SafetyFactor = result.SafetyFactor;
 //                job.ProbabilityOfFailure = result.ProbabilityOfFailure;
@@ -469,7 +468,7 @@
             {
                 if (logMessage.Subject != null)
                 {
-                    RWScenarioProfileResult job = (RWScenarioProfileResult)runningJobs[(ICalculation)logMessage.Subject];
+                    var job = (RegionalScenarioProfileResult)runningJobs[(ICalculation)logMessage.Subject];
                     logMessage.Subject = job.Location;                 
                 }
             }
@@ -480,25 +479,25 @@
         /// <summary>
         /// Fill the results for the scenarios
         /// </summary>
-        private void FillResults(List<RWScenarioProfileResult> tasks)
+        private void FillResults(List<RegionalScenarioProfileResult> tasks)
         {
             // Fill scenariosResult structure with jobs just run 
 
             foreach (Location location in this.evaluationJob.Locations)
             {
                 try
                 {
-                    RWScenariosResult scenariosResult = new RWScenariosResult();
+                    RegionalScenariosResult scenariosResult = new RegionalScenariosResult();
 
                     if (this.evaluationJob.FailedEvaluatedLocations.IndexOf(location) < 0)
                     {
                         // scenarios were succesfully created, so results are available
-                        foreach (RWScenarioProfileResult job in tasks)
+                        foreach (RegionalScenarioProfileResult job in tasks)
                         {
                             if (job.LocationName.Equals(location.Name))
                             {
-                                RWScenarioResult scenarioResult = null;
-                                foreach (RWScenarioResult existingScenarioResult in scenariosResult.RWScenarioResults)
+                                RegionalScenarioResult scenarioResult = null;
+                                foreach (var existingScenarioResult in scenariosResult.RegionalScenarioResults)
                                 {
                                     if (existingScenarioResult.ScenarioType == job.ScenarioType)
                                     {
@@ -508,19 +507,19 @@
 
                                 if (scenarioResult == null)
                                 {
-                                    scenarioResult = new RWScenarioResult();
+                                    scenarioResult = new RegionalScenarioResult();
                                     scenarioResult.ScenarioType = job.ScenarioType;
 
-                                    scenariosResult.RWScenarioResults.Add(scenarioResult);
+                                    scenariosResult.RegionalScenarioResults.Add(scenarioResult);
                                 }
 
-                                scenarioResult.RWScenarioProfileResults.Add(job);
+                                scenarioResult.RegionalScenarioProfileResults.Add(job);
                             }
                         }
 
                         // Combine results
 
-                        foreach (RWScenarioResult scenarioResult in scenariosResult.RWScenarioResults)
+                        foreach (var scenarioResult in scenariosResult.RegionalScenarioResults)
                         {
                             this.CombineProfiles(scenarioResult);
                         }
@@ -541,7 +540,7 @@
                 }
                 catch (Exception e)
                 {
-                    RWScenariosResult scenariosResult = new RWScenariosResult
+                    RegionalScenariosResult scenariosResult = new RegionalScenariosResult
                                                             {
                                                                 CalculationResult = CalculationResult.RunFailed,
                                                                 SafetyFactor = double.NaN
@@ -552,12 +551,12 @@
 
         }
 
-        private void CombineProfiles(RWScenarioResult scenarioResult)
+        private void CombineProfiles(RegionalScenarioResult scenarioResult)
         {
             // combine results of profiles
 
             scenarioResult.SafetyFactor = Double.MaxValue;
-            foreach (RWScenarioProfileResult profileResult in scenarioResult.RWScenarioProfileResults)
+            foreach (var profileResult in scenarioResult.RegionalScenarioProfileResults)
             {
                 if (profileResult.CalculationResult == CalculationResult.Succeeded)
                 {
@@ -572,16 +571,16 @@
             if (scenarioResult.CalculationResult != CalculationResult.Succeeded)
             {
                 // no succesful calculations found
-                scenarioResult.CalculationResult = scenarioResult.RWScenarioProfileResults[0].CalculationResult;
-                scenarioResult.SafetyFactor = scenarioResult.RWScenarioProfileResults[0].SafetyFactor;
+                scenarioResult.CalculationResult = scenarioResult.RegionalScenarioProfileResults[0].CalculationResult;
+                scenarioResult.SafetyFactor = scenarioResult.RegionalScenarioProfileResults[0].SafetyFactor;
             }
         }
 
-        private void CombineScenarios(RWScenariosResult scenariosResult)
+        private void CombineScenarios(RegionalScenariosResult scenariosResult)
         {
             // combine results of scenarios
             scenariosResult.SafetyFactor = Double.MaxValue;
-            foreach (RWScenarioResult scenarioResult in scenariosResult.RWScenarioResults)
+            foreach (var scenarioResult in scenariosResult.RegionalScenarioResults)
             {
                 if (scenarioResult.CalculationResult == CalculationResult.Succeeded)
                 {