ReducedModelOptimization/src/reducedmodeloptimizer.hpp

#ifndef REDUCEDMODELOPTIMIZER_HPP
#define REDUCEDMODELOPTIMIZER_HPP

#include "drmsimulationmodel.hpp"
#include "csvfile.hpp"
#include "edgemesh.hpp"
#include "simulationmesh.hpp"
#include "linearsimulationmodel.hpp"
#include "matplot/matplot.h"
#include <Eigen/Dense>
#include "reducedmodeloptimizer_structs.hpp"

#ifdef POLYSCOPE_DEFINED
#include "polyscope/color_management.h"
#endif // POLYSCOPE_DEFINED
using FullPatternVertexIndex = VertexIndex;
using ReducedPatternVertexIndex = VertexIndex;

class ReducedModelOptimizer {

  std::shared_ptr<SimulationMesh> m_pReducedPatternSimulationMesh;
  std::shared_ptr<SimulationMesh> m_pFullPatternSimulationMesh;
  std::unordered_map<FullPatternVertexIndex, ReducedPatternVertexIndex>
      m_fullToReducedInterfaceViMap;
  std::unordered_map<FullPatternVertexIndex, FullPatternVertexIndex>
      m_fullPatternOppositeInterfaceViMap;
  std::unordered_map<size_t, size_t> nodeToSlot;
  std::unordered_map<size_t, std::unordered_set<size_t>> slotToNode;
#ifdef POLYSCOPE_DEFINED
#endif // POLYSCOPE_DEFINED

public:
  inline static int fanSize{6};
  inline static VectorType patternPlaneNormal{0, 0, 1};
  ReducedModelOptimization::Results optimize(const ReducedModelOptimization::Settings &xRanges,
                                             const std::vector<ReducedModelOptimization::SimulationScenario> &simulationScenarios =
                                                 std::vector<ReducedModelOptimization::SimulationScenario>());
  double operator()(const Eigen::VectorXd &x, Eigen::VectorXd &) const;

  ReducedModelOptimizer(const std::vector<size_t> &numberOfNodesPerSlot);
  static void computeReducedModelSimulationJob(
      const SimulationJob &simulationJobOfFullModel,
      const std::unordered_map<size_t, size_t> &simulationJobFullToReducedMap,
      SimulationJob &simulationJobOfReducedModel);

  SimulationJob
  getReducedSimulationJob(const SimulationJob &fullModelSimulationJob);

  void initializePatterns(PatternGeometry &fullPattern, PatternGeometry &reducedPatterm,
      const std::unordered_set<size_t> &reducedModelExcludedEges, const int &optimizationParameters);

  static void runSimulation(const std::string &filename,
                            std::vector<double> &x);

  static double objective(double x2, double A, double J, double I2, double I3, double x3,
                          double innerHexagonRotationAngle);
  static double objective(double b, double r, double E);

  static std::vector<std::shared_ptr<SimulationJob>>
    createScenarios(const std::shared_ptr<SimulationMesh> &pMesh,
                    const std::unordered_map<size_t, size_t>
                        &fullPatternOppositeInterfaceViMap);

  static void createSimulationMeshes(
      PatternGeometry &fullModel, PatternGeometry &reducedModel,
      std::shared_ptr<SimulationMesh> &pFullPatternSimulationMesh,
      std::shared_ptr<SimulationMesh> &pReducedPatternSimulationMesh);
  static void computeMaps(
      const std::unordered_set<size_t> &reducedModelExcludedEdges,
      const std::unordered_map<size_t, std::unordered_set<size_t>> &slotToNode,
      PatternGeometry &fullPattern, PatternGeometry &reducedPattern,
      std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex>
          &reducedToFullInterfaceViMap,
      std::unordered_map<FullPatternVertexIndex, ReducedPatternVertexIndex>
          &fullToReducedInterfaceViMap,
      std::unordered_map<FullPatternVertexIndex, ReducedPatternVertexIndex>
          &fullPatternOppositeInterfaceViMap);
  static void
  visualizeResults(const std::vector<std::shared_ptr<SimulationJob>>
                       &fullPatternSimulationJobs,
                   const std::vector<std::shared_ptr<SimulationJob>>
                       &reducedPatternSimulationJobs,
                   const std::vector<ReducedModelOptimization::SimulationScenario> &simulationScenarios,
                   const std::unordered_map<ReducedPatternVertexIndex,
                                            FullPatternVertexIndex>
                       &reducedToFullInterfaceViMap);
  static void registerResultsForDrawing(
      const std::shared_ptr<SimulationJob> &pFullPatternSimulationJob,
      const std::shared_ptr<SimulationJob> &pReducedPatternSimulationJob,
      const std::unordered_map<ReducedPatternVertexIndex,
                               FullPatternVertexIndex>
          &reducedToFullInterfaceViMap);

  static double
  computeRawError(const std::vector<Vector6d> &reducedPatternDisplacements,
                  const std::vector<Vector6d> &fullPatternDisplacements,
                  const std::unordered_map<ReducedPatternVertexIndex,
                                           FullPatternVertexIndex>
                      &reducedToFullInterfaceViMap);

  static double
  computeError(const std::vector<Vector6d> &reducedPatternDisplacements,
               const std::vector<Vector6d> &fullPatternDisplacements,
               const std::unordered_map<ReducedPatternVertexIndex,
                                        FullPatternVertexIndex>
                   &reducedToFullInterfaceViMap,
               const double &normalizationFactor);

  static double objective(double E, double A, double innerHexagonSize, double innerHexagonRotationAngle);
  private:
    static void computeDesiredReducedModelDisplacements(
        const SimulationResults &fullModelResults,
        const std::unordered_map<size_t, size_t> &displacementsReducedToFullMap,
        Eigen::MatrixX3d &optimalDisplacementsOfReducedModel);
    static ReducedModelOptimization::Results runOptimization(const ReducedModelOptimization::Settings &settings);
  std::vector<std::shared_ptr<SimulationJob>>
  createScenarios(const std::shared_ptr<SimulationMesh> &pMesh);
  void computeMaps(PatternGeometry &fullModel, PatternGeometry &reducedPattern,
                   const std::unordered_set<size_t> &reducedModelExcludedEges);
  void createSimulationMeshes(PatternGeometry &fullModel,
                              PatternGeometry &reducedModel);
  static void
  initializeOptimizationParameters(const std::shared_ptr<SimulationMesh> &mesh, const int &optimizationParamters);

  static double objective(long n, const double *x);
  FormFinder simulator;
  void computeObjectiveValueNormalizationFactors();
};
void updateMesh(long n, const double *x);
#endif // REDUCEDMODELOPTIMIZER_HPP