ReducedModelOptimization/src/reducedmodeloptimizer.hpp

#ifndef REDUCEDMODELOPTIMIZER_HPP
#define REDUCEDMODELOPTIMIZER_HPP

#include "beamformfinder.hpp"
#include "edgemesh.hpp"
#include "elementalmesh.hpp"
#include "matplot/matplot.h"
#include <Eigen/Dense>

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;
  std::vector<double> initialGuess;

public:
  enum SimulationScenario {
    Axial,
    Shear,
    Bending,
    Dome,
    Saddle,
    NumberOfSimulationScenarios
  };
  inline static const std::string simulationScenarioStrings[] = {
      "Axial", "Shear", "Bending", "Double", "Saddle"};
  void optimize(const std::vector<SimulationScenario> &simulationScenarios =
                    std::vector<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(
      FlatPattern &fullPattern, FlatPattern &reducedPatterm,
      const std::unordered_set<size_t> &reducedModelExcludedEges);

  void setInitialGuess(std::vector<double> v);

  static void runBeamOptimization();

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

  static double objective(double x0, double x1, double x2, double x3);

private:
  void
  visualizeResults(const std::vector<std::shared_ptr<SimulationJob>>
                       &fullPatternSimulationJobs,
                   const std::vector<SimulationScenario> &simulationScenarios);
  static void computeDesiredReducedModelDisplacements(
      const SimulationResults &fullModelResults,
      const std::unordered_map<size_t, size_t> &displacementsReducedToFullMap,
      Eigen::MatrixX3d &optimalDisplacementsOfReducedModel);
  static Eigen::VectorXd
  runOptimization(double (*pObjectiveFunction)(long, const double *));
  std::vector<std::shared_ptr<SimulationJob>>
  createScenarios(const std::shared_ptr<SimulationMesh> &pMesh);
  void computeMaps(FlatPattern &fullModel, FlatPattern &reducedPattern,
                   const std::unordered_set<size_t> &reducedModelExcludedEges);
  void createSimulationMeshes(FlatPattern &fullModel,
                              FlatPattern &reducedModel);
  static void
  initializeStiffnesses(const std::shared_ptr<SimulationMesh> &mesh);

  static double
  computeError(const SimulationResults &reducedPatternResults,
               const Eigen::MatrixX3d &optimalReducedPatternDisplacements);
  static double objective(long n, const double *x);
};

#endif // REDUCEDMODELOPTIMIZER_HPP