ReducedModelOptimization/src/main.cpp

#include "beamformfinder.hpp"
#include "csvfile.hpp"
#include "edgemesh.hpp"
#include "flatpattern.hpp"
#include "polyscope/curve_network.h"
#include "polyscope/point_cloud.h"
#include "polyscope/polyscope.h"
#include "reducedmodeloptimizer.hpp"
#include "simulationhistoryplotter.hpp"
#include "trianglepattterntopology.hpp"
#include <chrono>
#include <filesystem>
#include <iostream>
#include <iterator>
#include <stdexcept>
#include <string>
#include <vcg/complex/algorithms/update/position.h>

int main(int argc, char *argv[]) {
  // Create reduced models
  //  FormFinder::runUnitTests();
  const std::vector<size_t> numberOfNodesPerSlot{1, 0, 0, 2, 1, 2, 1};
  std::vector<vcg::Point2i> singleBarReducedModelEdges{vcg::Point2i(0, 3)};
  FlatPattern singleBarReducedModel(numberOfNodesPerSlot,
                                    singleBarReducedModelEdges);
  singleBarReducedModel.setLabel("SingleBar_reduced");
  singleBarReducedModel.scale(0.03);

  std::vector<vcg::Point2i> CWreducedModelEdges{vcg::Point2i(1, 5),
                                                vcg::Point2i(3, 1)};
  FlatPattern CWReducedModel(numberOfNodesPerSlot, CWreducedModelEdges);
  CWReducedModel.setLabel("CCW_reduced");
  CWReducedModel.scale(0.03);

  std::vector<vcg::Point2i> CCWreducedModelEdges{vcg::Point2i(1, 5),
                                                 vcg::Point2i(3, 5)};
  FlatPattern CCWReducedModel(numberOfNodesPerSlot, CCWreducedModelEdges);
  CCWReducedModel.setLabel("CW_reduced");
  CCWReducedModel.scale(0.03);

  std::vector<FlatPattern *> reducedModels{&singleBarReducedModel,
                                           &CWReducedModel, &CCWReducedModel};

  // Define the ranges that the optimizer will use
  ReducedModelOptimizer::xRange beamWidth{"B", 0.5, 1.5};
  ReducedModelOptimizer::xRange beamDimensionsRatio{"bOverh", 0.7, 1.3};
  ReducedModelOptimizer::xRange beamE{"E", 0.1, 1.9};
  ReducedModelOptimizer::xRange innerHexagonSize{"HexagonSize", 0.1, 0.9};
  // Test set of full patterns
  std::string fullPatternsTestSetDirectory = "TestSet";
  if (!std::filesystem::exists(
          std::filesystem::path(fullPatternsTestSetDirectory))) {
    std::cerr << "Full pattern directory does not exist: "
              << fullPatternsTestSetDirectory << std::endl;
    return 1;
  }
  //      "/home/iason/Documents/PhD/Research/Approximating shapes with flat "
  //      "patterns/Pattern_enumerator/Results/1v_0v_2e_1e_1c_6fan/3/Valid";
  std::vector<std::pair<FlatPattern *, FlatPattern *>> patternPairs;
  for (const auto &entry :
       filesystem::directory_iterator(fullPatternsTestSetDirectory)) {
    const auto filepath =
        //        std::filesystem::path(fullPatternsTestSetDirectory).append("305.ply");
        entry.path();
    const std::string filepathString = filepath.string();
    const std::string tiledSuffix = "_tiled.ply";
    if (filepathString.compare(filepathString.size() - tiledSuffix.size(),
                               tiledSuffix.size(), tiledSuffix) == 0) {
      continue;
    }

    FlatPattern fullPattern(filepathString);
      fullPattern.setLabel(filepath.stem().string());
      fullPattern.scale(0.03);
    //for (int reducedPatternIndex = 0;
    //     reducedPatternIndex < reducedModels.size(); reducedPatternIndex++) {
      FlatPattern *pFullPattern = new FlatPattern();
      pFullPattern->copy(fullPattern);
      FlatPattern *pReducedPattern = new FlatPattern();
      //pReducedPattern->copy(*reducedModels[reducedPatternIndex]);
            pReducedPattern->copy(*reducedModels[0]);
      patternPairs.push_back(std::make_pair(pFullPattern, pReducedPattern));
    //}
  }

  //  for (double rangeOffset = 0.15; rangeOffset <= 0.95; rangeOffset += 0.05)
  //  {
  ReducedModelOptimizer::Settings settings_optimization;
  settings_optimization.xRanges = {beamWidth, beamDimensionsRatio, beamE,
                                   innerHexagonSize};

  //  for (settings_optimization.numberOfFunctionCalls = 100;
  //       settings_optimization.numberOfFunctionCalls < 5000;
  //       settings_optimization.numberOfFunctionCalls += 100) {
  settings_optimization.numberOfFunctionCalls = 100;
  const std::string optimizationSettingsString =
      settings_optimization.toString();
  std::string optimiziationResultsDirectory = "../OptimizationResults";
//  if (argc == 1) {
//      optimiziationResultsDirectory = argv[0];
//}
  std::filesystem::path thisOptimizationDirectory(
      std::filesystem::path(optimiziationResultsDirectory)
          .append(optimizationSettingsString));
  std::filesystem::create_directories(thisOptimizationDirectory);
  std::cout << optimizationSettingsString << std::endl;
  csvFile csv_settings(std::filesystem::path(thisOptimizationDirectory)
                           .append("settings.csv")
                           .string(),
                       true);
  settings_optimization.writeTo(csv_settings);

  double totalError = 0;
  int totalNumberOfSimulationCrashes = 0;
  std::vector<ReducedModelOptimizer::Results> optimizationResults_testSet(
      patternPairs.size());
  auto start = std::chrono::high_resolution_clock::now();

  //#pragma omp parallel for
  for (int patternPairIndex = 0; patternPairIndex < patternPairs.size();
       patternPairIndex++) {
    const std::vector<size_t> numberOfNodesPerSlot{1, 0, 0, 2, 1, 2, 1};
    ReducedModelOptimizer optimizer(numberOfNodesPerSlot);
    optimizer.initializePatterns(*patternPairs[patternPairIndex].first,
                                 *patternPairs[patternPairIndex].second, {});
    ReducedModelOptimizer::Results optimizationResults =
        optimizer.optimize(settings_optimization, {ReducedModelOptimizer::SimulationScenario::Dome});

    totalError += optimizationResults.objectiveValue;
    optimizationResults_testSet[patternPairIndex] = optimizationResults;
    totalNumberOfSimulationCrashes +=
        optimizationResults.numberOfSimulationCrashes;
    optimizationResults.draw();
  }
  auto end = std::chrono::high_resolution_clock::now();
  auto runtime_ms =
      std::chrono::duration_cast<std::chrono::milliseconds>(end - start);

  for (int patternPairIndex = 0; patternPairIndex < patternPairs.size();
       patternPairIndex++) {
    std::filesystem::path saveToPath(
        std::filesystem::path(thisOptimizationDirectory)
            .append(patternPairs[patternPairIndex].first->getLabel() + "@" +
                    patternPairs[patternPairIndex].second->getLabel()));
    std::filesystem::create_directories(std::filesystem::path(saveToPath));

    optimizationResults_testSet[patternPairIndex].save(saveToPath.string());
  }
  csvFile statistics(std::filesystem::path(thisOptimizationDirectory)
                         .append("statistics.csv")
                         .string(),
                     false);

  // Write header to csv
  statistics << "FullPattern@ReducedPattern"
             << "Obj value";
  for (const ReducedModelOptimizer::xRange &range :
       settings_optimization.xRanges) {
    statistics << range.label;
  }
  statistics << "Time(s)";
  statistics << "#Crashes";
  statistics << endrow;

  // Write data
  for (int patternPairIndex = 0; patternPairIndex < patternPairs.size();
       patternPairIndex++) {
    statistics << patternPairs[patternPairIndex].first->getLabel() + "@" +
                      patternPairs[patternPairIndex].second->getLabel();
    statistics << optimizationResults_testSet[patternPairIndex].objectiveValue;
    for (const double &optimalX :
         optimizationResults_testSet[patternPairIndex].x) {
      statistics << optimalX;
    }

    for (int unusedXVarCounter = 0;
         unusedXVarCounter <
         settings_optimization.xRanges.size() -
             optimizationResults_testSet[patternPairIndex].x.size();
         unusedXVarCounter++) {
      statistics << "-";
    }

    statistics << optimizationResults_testSet[patternPairIndex].time;
    if (totalNumberOfSimulationCrashes == 0) {
      statistics << "No crashes";
    } else {
      statistics << totalNumberOfSimulationCrashes;
    }
    statistics << endrow;
  }
  statistics << endrow;
  //  }

  for (auto patternPair : patternPairs) {
    delete patternPair.first;
    delete patternPair.second;
  }
  return 0;
}