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("CW_reduced");
  CWReducedModel.scale(0.03);

  std::vector<vcg::Point2i> CCWreducedModelEdges{vcg::Point2i(1, 5),
                                                 vcg::Point2i(3, 5)};
  FlatPattern CCWReducedModel(numberOfNodesPerSlot, CCWreducedModelEdges);
  CCWReducedModel.setLabel("CCW_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 *pFullPattern = new FlatPattern(filepathString);
    pFullPattern->setLabel(filepath.stem().string());
    pFullPattern->scale(0.03);
    FlatPattern *pReducedPattern = new FlatPattern();
    pReducedPattern->copy(*reducedModels[1]);
    patternPairs.push_back(std::make_pair(pFullPattern, pReducedPattern));
  }

  //  for (double rangeOffset = 0.15; rangeOffset <= 0.95; rangeOffset += 0.05)
  //  {
  ReducedModelOptimizer::Settings settings;
  for (settings.maxSimulations = 100; settings.maxSimulations < 5000;
       settings.maxSimulations += 100) {
    std::string xRangesString = beamWidth.toString() + " " +
                                beamDimensionsRatio.toString() + " " +
                                beamE.toString();
    std::cout << xRangesString << std::endl;
    settings.xRanges = {beamWidth, beamDimensionsRatio, beamE,
                        innerHexagonSize};
    //    std::filesystem::path thisOptimizationDirectory(
    //        std::filesystem::path("../OptimizationResults").append(xRangesString));
    //    std::filesystem::create_directories(thisOptimizationDirectory);
    //    csvfile thisOptimizationStatistics(
    //        std::filesystem::path(thisOptimizationDirectory)
    //            .append("statistics.csv")
    //            .string(),
    //        true);

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

    //#pragma omp parallel for
    for (int patternPairIndex = 0; patternPairIndex < patternPairs.size();
         patternPairIndex++) {
      // const auto filepathString = filepath.string();
      // Use only the base triangle version
      //    std::cout << "Full pattern:" << filepathString << std::endl;
      //    for (int reducedPatternIndex = 0;
      //         reducedPatternIndex < reducedModels.size();
      //         reducedPatternIndex++) {
      //          FlatPattern *pReducedModel =
      // reducedModels[reducedPatternIndex];
      std::unordered_set<size_t> optimizationExcludedEi;
      //    if (pReducedModel !=
      //        reducedModels[0]) { // assumes that the singleBar reduced model
      //                            //              is
      //      // the
      //      // first in the reducedModels vector
      //      optimizationExcludedEi.insert(0);
      //    }
      //    FlatPattern cp;
      //    cp.copy(*reducedModels[0]);
      const std::vector<size_t> numberOfNodesPerSlot{1, 0, 0, 2, 1, 2, 1};
      ReducedModelOptimizer optimizer(numberOfNodesPerSlot);
      optimizer.initializePatterns(*patternPairs[patternPairIndex].first,
                                   *patternPairs[patternPairIndex].second,
                                   optimizationExcludedEi);
      //    optimizer.optimize({ReducedModelOptimizer::Axial});
      ReducedModelOptimizer::Results optimizationResults =
          optimizer.optimize(settings);

      totalError += optimizationResults.objectiveValue;
      resultsPerPattern[patternPairIndex] =
          std::make_pair(patternPairs[patternPairIndex].first->getLabel(),
                         optimizationResults);
      totalNumberOfSimulationCrashes +=
          optimizationResults.numberOfSimulationCrashes;
      //      std::cout << "Have optimized " << ++patternsOptimized << "/"
      //                << static_cast<int>(
      //                       std::distance(std::filesystem::directory_iterator(
      //                                         fullPatternsTestSetDirectory),
      //                                     std::filesystem::directory_iterator()))
      //                << " patterns." << std::endl;
      //    }
    }
    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("../OptimizationResults")
    //                           .append(resultsPerPattern[patternPairIndex].first));
    //        std::filesystem::create_directory(std::filesystem::path(saveToPath));

    //      resultsPerPattern[patternPairIndex].second.save(saveToPath);
    //    }

    if (!std::filesystem::exists(
            std::filesystem::path("OptimizationResults/"))) {
      std::filesystem::create_directory(
          std::filesystem::path("OptimizationResults"));
    }

    csvfile statistics(std::filesystem::path("OptimizationResults")
                           .append("statistics.csv")
                           .string(),
                       false);
    for (const auto &range : settings.xRanges) {
      statistics << range.min << range.max;
    }
    statistics << settings.maxSimulations;
    if (totalNumberOfSimulationCrashes == 0) {
      statistics << "No crashes";
    } else {
      statistics << totalNumberOfSimulationCrashes;
    }

    statistics << totalError;
    for (const auto &patternObjectiveValue : resultsPerPattern) {
      statistics << patternObjectiveValue.first;
      statistics << patternObjectiveValue.second.objectiveValue;
      for (const double &optimalX : patternObjectiveValue.second.x) {
        statistics << optimalX;
      }
    }
    statistics << runtime_ms.count() / 1000.0;

    statistics << endrow;
  }

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