Merge pull request #8 from suehtamacv/IO_Functions

Io functions

src/SimulationTypes/Simulation_NSGA2_RegnPlac.cpp

@@ -236,7 +236,7 @@ void Simulation_NSGA2_RegnPlac::save(std::string SimConfigFileName)
 
     BOOST_ASSERT_MSG(SimConfigFile.is_open(), "Output file is not open");
 
-    // A FAZER = Implementar melhor o salve dos algoritmos
+    // To do: Better algorithms saving
     SimConfigFile << std::endl << "  [algorithms]" << std::endl;
     SimConfigFile << "  RoutingAlgorithm = " <<
                   RoutingAlgorithm::RoutingAlgorithmNicknames.left.at(Routing_Algorithm) <<

src/SimulationTypes/Simulation_NetworkLoad.cpp

@@ -389,6 +389,28 @@ void Simulation_NetworkLoad::load_file(std::string ConfigFileName)
     NetworkLoadMax = VariablesMap["sim_info.NetworkLoadMax"].as<long double>();
     NetworkLoadStep = VariablesMap["sim_info.NetworkLoadStep"].as<long double>();
 
+    std::cout << std::endl << "-> Define the file where to store the results."
+              << std::endl;
+    do
+        {
+        std::cin >> FileName;
+
+        if (std::cin.fail())
+            {
+            std::cin.clear();
+            std::cin.ignore();
+
+            std::cerr << "Invalid filename." << std::endl;
+            std::cout << std::endl << "-> Define the file where to store the results."
+                      << std::endl;
+            }
+        else
+            {
+            break;
+            }
+        }
+    while (1);
+
     create_Simulations();
 
     hasLoaded = true;

src/SimulationTypes/Simulation_PSROptimization.cpp

@@ -6,6 +6,11 @@
 #include <Calls.h>
 #include <RWA.h>
 #include <Structure/Link.h>
+#include <sstream>
+#include <boost/assert.hpp>
+#include <boost/assign.hpp>
+#include <boost/program_options.hpp>
+#include <map>
 
 using namespace Simulations;
 
@@ -270,14 +275,149 @@ void Simulation_PSROptimization::create_Simulation()
 
 }
 
-void Simulation_PSROptimization::save(std::string)
+void Simulation_PSROptimization::save(std::string SimConfigFileName)
 {
-    // save parameters in file
+    SimulationType::save(SimConfigFileName);
+
+    std::ofstream SimConfigFile(SimConfigFileName,
+                                std::ofstream::out | std::ofstream::app);
+
+    BOOST_ASSERT_MSG(SimConfigFile.is_open(), "Output file is not open");
+
+    SimConfigFile << "  NetworkType = " << NetworkTypesNicknames.left.at(
+                      Type) << std::endl;
+
+    SimConfigFile.close();
+
+    Link::save(SimConfigFileName, T);
+
+    SimConfigFile.open(SimConfigFileName,
+                                    std::ofstream::out | std::ofstream::app);
+    BOOST_ASSERT_MSG(SimConfigFile.is_open(), "Output file is not open");
+
+    SimConfigFile << std::endl << "  [algorithms]" << std::endl << std::endl;
+    SimConfigFile << "  WavelengthAssignmentAlgorithm = " <<
+                  WavelengthAssignmentAlgorithm::WavelengthAssignmentAlgorithmNicknames.left.at(
+                      WavAssign_Algorithm) << std::endl;
+    if(Type == TranslucentNetwork)
+        {
+        SimConfigFile << "  RegeneratorPlacementAlgorithm = " <<
+                  RegeneratorPlacementAlgorithm::RegeneratorPlacementNicknames.left.at(
+                      RegPlacement_Algorithm) << std::endl;
+        SimConfigFile << "  RegeneratorAssignmentAlgorithm = " <<
+                  RegeneratorAssignmentAlgorithm::RegeneratorAssignmentNicknames.left.at(
+                      RegAssignment_Algorithm) << std::endl;
+        }
+
+    SimConfigFile << std::endl << "  [sim_info]" << std::endl << std::endl;
+    SimConfigFile << "  MinimumPSRExponent = " << NMin << std::endl;
+    SimConfigFile << "  MaximumPSRExponent = " << NMax << std::endl;
+    SimConfigFile << "  PSRCosts =";
+    for(auto &cost : Costs)
+        SimConfigFile << " " << PSR::Cost::CostsNicknames.left.at(cost->Type);
+    SimConfigFile << std::endl;
+    SimConfigFile << "  NumCalls = " << NumCalls << std::endl;
+    SimConfigFile << "  NetworkLoad = " << OptimizationLoad << std::endl;
+
+    SimConfigFile << std::endl;
+    T->save(SimConfigFileName);
 }
 
-void Simulation_PSROptimization::load_file(std::string)
+void Simulation_PSROptimization::load_file(std::string ConfigFileName)
 {
-    // load parameters from a file
+    using namespace boost::program_options;
+
+    options_description ConfigDesctription("Configurations Data");
+    ConfigDesctription.add_options()("general.SimulationType",
+                                     value<std::string>()->required(), "Simulation Type")
+            ("general.NetworkType", value<std::string>()->required(), "Network Type")
+            ("general.AvgSpanLength", value<long double>()->required(),
+             "Distance Between Inline Amps.")
+            ("algorithms.WavelengthAssignmentAlgorithm", value<std::string>()->required(),
+             "Wavelength Assignment Algorithm")
+            ("algorithms.RegeneratorPlacementAlgorithm", value<std::string>(),
+             "Regenerator Placement Algorithm")
+            ("algorithms.RegeneratorAssignmentAlgorithm", value<std::string>(),
+             "Regenerator Assignment Algorithm")
+            ("sim_info.MinimumPSRExponent", value<int>()->required(), "Minimum PSR Exponent")
+            ("sim_info.MaximumPSRExponent", value<int>()->required(), "Maximum PSR Exponent")
+            ("sim_info.PSRCosts", value<std::vector<std::string>>()->multitoken(), "PSR Costs")
+            ("sim_info.NumCalls", value<long double>()->required(), "Number of Calls")
+            ("sim_info.NetworkLoad", value<long double>()->required(), "Network Load");
+
+    variables_map VariablesMap;
+
+    std::ifstream ConfigFile(ConfigFileName, std::ifstream::in);
+    BOOST_ASSERT_MSG(ConfigFile.is_open(), "Input file is not open");
+
+    store(parse_config_file<char>(ConfigFile, ConfigDesctription, true),
+          VariablesMap);
+    ConfigFile.close();
+    notify(VariablesMap);
+
+    T = std::shared_ptr<Topology>(new Topology(ConfigFileName));
+    Type = NetworkTypesNicknames.right.at(
+               VariablesMap["general.NetworkType"].as<std::string>());
+    Link::DefaultAvgSpanLength =
+        VariablesMap["general.AvgSpanLength"].as<long double>();
+    T->set_avgSpanLength(VariablesMap["general.AvgSpanLength"].as<long double>());
+
+    WavAssign_Algorithm =
+        WavelengthAssignmentAlgorithm::WavelengthAssignmentAlgorithmNicknames.right.at(
+            VariablesMap["algorithms.WavelengthAssignmentAlgorithm"].as<std::string>());
+    if(Type == Network_Type::TranslucentNetwork)
+        {
+        RegPlacement_Algorithm =
+            RegeneratorPlacementAlgorithm::RegeneratorPlacementNicknames.right.at(
+                VariablesMap["algorithms.RegeneratorPlacementAlgorithm"].as<std::string>());
+        RegAssignment_Algorithm =
+            RegeneratorAssignmentAlgorithm::RegeneratorAssignmentNicknames.right.at(
+                VariablesMap["algorithms.RegeneratorAssignmentAlgorithm"].as<std::string>());
+        }
+
+    NMin = VariablesMap["sim_info.MinimumPSRExponent"].as<int>();
+    NMax = VariablesMap["sim_info.MaximumPSRExponent"].as<int>();
+
+    std::vector<std::string> CostsList = VariablesMap.find("sim_info.PSRCosts")->second.as<std::vector<std::string>>();
+    for(auto &costs : CostsList)
+    {
+        std::istringstream PSR_Costs(costs);
+        std::string Aux;
+        while(PSR_Costs.tellg() != -1) // Reading the last cost twice
+        {
+            PSR_Costs >> Aux;
+            Costs.push_back(PSR::Cost::createCost(
+                            (PSR::Cost::PossibleCosts) PSR::Cost::CostsNicknames.right.at(Aux), NMin, NMax, T));
+        }
+    }
+
+    NumCalls = VariablesMap["sim_info.NumCalls"].as<long double>();
+    OptimizationLoad = VariablesMap["sim_info.NetworkLoad"].as<long double>();
+
+    std::cout << std::endl << "-> Define the file where to store the coefficients."
+              << std::endl;
+
+    do
+        {
+        std::cin >> FileName;
+
+        if (std::cin.fail())
+            {
+            std::cin.clear();
+            std::cin.ignore();
+
+            std::cerr << "Invalid filename." << std::endl;
+            std::cout << std::endl << "-> Define the file where to store the coefficients."
+                      << std::endl;
+            }
+        else
+            {
+            break;
+            }
+        }
+    while (1);
+
+    hasLoaded = true;
 }
 
 void Simulation_PSROptimization::print()
@@ -311,8 +451,8 @@ void Simulation_PSROptimization::print()
     std::cout << "-> Maximum PSR Exponent = " << NMax << std::endl;
 
     std::cout << "-> PSR Costs =";
-    for(auto Iterator = Costs.begin(); Iterator != Costs.end(); Iterator++)
-        std::cout << " " << PSR::Cost::CostsNicknames.left.at((*Iterator)->Type) << std::endl;
+    for(auto &cost : Costs)
+        std::cout << " " << PSR::Cost::CostsNicknames.left.at(cost->Type) << std::endl;
 
     std::cout << "-> Number of Calls = " << NumCalls << std::endl;
     std::cout << "-> Network Load = " << OptimizationLoad << std::endl;
@@ -351,6 +491,10 @@ void Simulation_PSROptimization::run()
         }
 
     hasRun = true;
+
+    // Saving Sim. Configurations
+    std::string ConfigFileName = "SimConfigFile.ini"; // Name of the file
+    save(ConfigFileName);
 }
 
 double Simulation_PSROptimization::Fitness::operator()(

src/SimulationTypes/Simulation_RegeneratorNumber.cpp

@@ -341,6 +341,28 @@ void Simulation_RegeneratorNumber::load_file(std::string ConfigFileName)
     numTranslucentNodes =
         VariablesMap["sim_info.numTranslucentNodes"].as<long double>();
 
+    std::cout << std::endl << "-> Define the file where to store the results."
+              << std::endl;
+    do
+        {
+        std::cin >> FileName;
+
+        if (std::cin.fail())
+            {
+            std::cin.clear();
+            std::cin.ignore();
+
+            std::cerr << "Invalid filename." << std::endl;
+            std::cout << std::endl << "-> Define the file where to store the results."
+                      << std::endl;
+            }
+        else
+            {
+            break;
+            }
+        }
+    while (1);
+
     createSimulations();
 
     hasLoaded = true;

src/SimulationTypes/Simulation_StatisticalTrend.cpp

@@ -382,6 +382,28 @@ void Simulation_StatisticalTrend::load_file(std::string ConfigFileName)
     NetworkLoad = VariablesMap["sim_info.NetworkLoad"].as<long double>();
     NumRepetitions = VariablesMap["sim_info.NumRepetitions"].as<long double>();
 
+    std::cout << std::endl << "-> Define the file where to store the results."
+              << std::endl;
+    do
+        {
+        std::cin >> FileName;
+
+        if (std::cin.fail())
+            {
+            std::cin.clear();
+            std::cin.ignore();
+
+            std::cerr << "Invalid filename." << std::endl;
+            std::cout << std::endl << "-> Define the file where to store the results."
+                      << std::endl;
+            }
+        else
+            {
+            break;
+            }
+        }
+    while (1);
+
     runLoadNX = false;
     hasLoaded = true;