fixed start-of-distributed-simulator-issue

minor refactoring/renaming

Author: ChristophBodenstein

TimeNETOptimizationEnvironment/src/toe/simulation/SimulationCache.java

@@ -482,7 +482,7 @@ private parameter findParameterInListByName(String name, ArrayList<parameter> li
      * @param simulationCounter Counter of Simulations
      * @return List of parsers with Simulation-Results, like in real simulation
      */
-    public ArrayList<SimulationType> getListOfCompletedSimulationParsers(ArrayList<ArrayList<parameter>> parameterSetList, int simulationCounter) {
+    public ArrayList<SimulationType> getListOfCompletedSimulations(ArrayList<ArrayList<parameter>> parameterSetList, int simulationCounter) {
         setLocalSimulationCounter(simulationCounter);
         ArrayList<SimulationType> myParserList = new ArrayList<>();
         ArrayList<MeasureType> listOfMeasureWithGivenParameters;

TimeNETOptimizationEnvironment/src/toe/simulation/SimulatorCached.java

@@ -43,7 +43,7 @@ public SimulatorCached() {
     @Override
     public void initSimulator(ArrayList<ArrayList<parameter>> listOfParameterSetsTMP, boolean log) {
         if (mySimulationCache != null) {
-            this.myListOfSimulations = mySimulationCache.getListOfCompletedSimulationParsers(listOfParameterSetsTMP, support.getGlobalSimulationCounter());
+            this.myListOfSimulations = mySimulationCache.getListOfCompletedSimulations(listOfParameterSetsTMP, support.getGlobalSimulationCounter());
             support.setGlobalSimulationCounter(support.getGlobalSimulationCounter() + myListOfSimulations.size());
         } else {
             support.log("No local Simulation file loaded. Simulation not possible.", typeOfLogLevel.ERROR);

TimeNETOptimizationEnvironment/src/toe/simulation/SimulatorCachedLocal.java

@@ -8,6 +8,7 @@
 package toe.simulation;
 
 import java.util.ArrayList;
+import java.util.Iterator;
 import toe.datamodel.parameter;
 import toe.datamodel.SimulationType;
 import toe.support;
@@ -21,7 +22,7 @@
  */
 public class SimulatorCachedLocal extends SimulatorCached {
 
-    private ArrayList<SimulationType> myListOfSimulationParsers = null;
+    private ArrayList<SimulationType> myListOfCompletedSimulations = null;
     private int status;
     private final Simulator myLocalSimulator = getNoCacheSimulator();
     private ArrayList< ArrayList<parameter>> remainingParametersets = new ArrayList<>();
@@ -45,7 +46,7 @@ public SimulatorCachedLocal() {
     @Override
     public void initSimulator(ArrayList< ArrayList<parameter>> listOfParameterSetsTMP, boolean log) {
 
-        this.myListOfSimulationParsers = null;
+        this.myListOfCompletedSimulations = null;
         remainingParametersets = new ArrayList<>();
         status = 0;
         this.listOfParameterSetsTMP = listOfParameterSetsTMP;
@@ -63,35 +64,43 @@ public void initSimulator(ArrayList< ArrayList<parameter>> listOfParameterSetsTM
     public void run() {
         if (mySimulationCache != null) {
             support.log("Will load available results from simulation cache.", typeOfLogLevel.INFO);
-            this.myListOfSimulationParsers = mySimulationCache.getListOfCompletedSimulationParsers(listOfParameterSetsTMP, support.getGlobalSimulationCounter());
+            this.myListOfCompletedSimulations = mySimulationCache.getListOfCompletedSimulations(listOfParameterSetsTMP, support.getGlobalSimulationCounter());
         } else {
             support.log("No local Simulation file loaded. Will build my own cache from scratch.", typeOfLogLevel.INFO);
             this.mySimulationCache = support.getMySimulationCache();
         }
 
-        if (this.myListOfSimulationParsers == null) {
+        if (this.myListOfCompletedSimulations == null) {
             support.log("No Simulation found in local Cache. Starting simulation.", typeOfLogLevel.INFO);
-            this.myListOfSimulationParsers = new ArrayList<>();
+            this.myListOfCompletedSimulations = new ArrayList<>();
         }
 
-        status = myListOfSimulationParsers.size() * 100 / listOfParameterSetsTMP.size();
-        support.setStatusText("Simulating " + myListOfSimulationParsers.size() + "/" + listOfParameterSetsTMP.size());
+        status = myListOfCompletedSimulations.size() * 100 / listOfParameterSetsTMP.size();
+        support.setStatusText("Simulating " + myListOfCompletedSimulations.size() + "/" + listOfParameterSetsTMP.size());
         //Increase Simulationcounter only if Simulation results are found in cache
         //Local or benchmark-simulators will update the counter on their own
-        support.setGlobalSimulationCounter(support.getGlobalSimulationCounter() + myListOfSimulationParsers.size());
+        support.setGlobalSimulationCounter(support.getGlobalSimulationCounter() + myListOfCompletedSimulations.size());
 
-        if (this.myListOfSimulationParsers.size() < listOfParameterSetsTMP.size()) {
+        if (this.myListOfCompletedSimulations.size() < listOfParameterSetsTMP.size()) {
             support.log("Some simulations were missing in cache. Will simulate them local/distributed.", typeOfLogLevel.INFO);
 
             for (ArrayList<parameter> myParameterset : listOfParameterSetsTMP) {
                 remainingParametersets.add(myParameterset);
             }
 
-            for (ArrayList<parameter> myParameterset : listOfParameterSetsTMP) {
-                for (SimulationType myListOfSimulationParser : this.myListOfSimulationParsers) {
+            ArrayList<parameter> myParameterset;
+            for (int i = 0; i < listOfParameterSetsTMP.size(); i++) {
+                myParameterset = listOfParameterSetsTMP.get(i);
+                support.spinInLabel();
+                support.setStatusText("Build new List:  " + i * 100 / listOfParameterSetsTMP.size() + " %");
+                //for (ArrayList<parameter> myParameterset : listOfParameterSetsTMP) {
+                for (SimulationType myListOfSimulationParser : this.myListOfCompletedSimulations) {
                     if (this.mySimulationCache.compareParameterList(myListOfSimulationParser.getListOfParametersFittedToBaseParameterset(), myParameterset)) {
                         remainingParametersets.remove(myParameterset);
                     }
+                    if (support.isCancelEverything()) {
+                        return;
+                    }
                 }
             }
             support.log("Size of Remaining ParameterList is " + remainingParametersets.size(), typeOfLogLevel.INFO);
@@ -100,30 +109,29 @@ public void run() {
             if (support.isCancelEverything()) {
                 return;
             }
-            myLocalSimulator.initSimulator(remainingParametersets, false);
-            //support.waitForEndOfSimulator(myLocalSimulator, support.getGlobalSimulationCounter(), support.DEFAULT_TIMEOUT);
 
             synchronized (myLocalSimulator) {
                 try {
+                    myLocalSimulator.initSimulator(remainingParametersets, false);
                     myLocalSimulator.wait();
                 } catch (InterruptedException ex) {
                     support.log("Problem waiting for end of non-cache-simulator.", typeOfLogLevel.ERROR);
                 }
             }
 
-            myListOfSimulationParsers.addAll(myLocalSimulator.getListOfCompletedSimulationParsers());
-            status = myListOfSimulationParsers.size() * 100 / listOfParameterSetsTMP.size();
+            myListOfCompletedSimulations.addAll(myLocalSimulator.getListOfCompletedSimulationParsers());
+            status = myListOfCompletedSimulations.size() * 100 / listOfParameterSetsTMP.size();
 
-            support.log("Size of resultList is " + myListOfSimulationParsers.size(), typeOfLogLevel.INFO);
+            support.log("Size of resultList is " + myListOfCompletedSimulations.size(), typeOfLogLevel.INFO);
 
             this.mySimulationCache.addListOfSimulationsToCache(myLocalSimulator.getListOfCompletedSimulationParsers());
             support.log("Size of SimulationCache: " + this.mySimulationCache.getCacheSize(), typeOfLogLevel.INFO);
         }
 
-        if (this.myListOfSimulationParsers != null) {
-            support.log("Adding " + myListOfSimulationParsers.size() + " Results to logfile.", typeOfLogLevel.INFO);
+        if (this.myListOfCompletedSimulations != null) {
+            support.log("Adding " + myListOfCompletedSimulations.size() + " Results to logfile.", typeOfLogLevel.INFO);
             //Print out a log file
-            support.addLinesToLogFileFromListOfParser(myListOfSimulationParsers, logFileName);
+            support.addLinesToLogFileFromListOfParser(myListOfCompletedSimulations, logFileName);
             support.log("SimulationCounter is now: " + support.getGlobalSimulationCounter(), typeOfLogLevel.INFO);
         }
 
@@ -162,7 +170,7 @@ public Simulator getNoCacheSimulator() {
      */
     @Override
     public ArrayList<SimulationType> getListOfCompletedSimulationParsers() {
-        return this.myListOfSimulationParsers;
+        return this.myListOfCompletedSimulations;
     }
 
     /**