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 FullModelVertexIndex = VertexIndex;
using ReducedModelVertexIndex = VertexIndex;

class ReducedModelOptimizer {
  std::shared_ptr<SimulationMesh> pReducedModelElementalMesh;
  std::shared_ptr<SimulationMesh> pFullModelElementalMesh;
  std::unordered_map<FullModelVertexIndex, ReducedModelVertexIndex>
      m_fullToReducedInterfaceViMap;
  std::unordered_map<ReducedModelVertexIndex, ReducedModelVertexIndex>
      m_fullPatternOppositeInterfaceViMap;
  std::unordered_map<size_t, size_t> nodeToSlot;
  std::unordered_map<size_t, std::unordered_set<size_t>> slotToNode;

public:
  Eigen::VectorXd optimize();
  double operator()(const Eigen::VectorXd &x, Eigen::VectorXd &) const;

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

  SimulationJob
  getReducedSimulationJob(const SimulationJob &fullModelSimulationJob);

  void initialize(FlatPattern &fullPattern, FlatPattern &reducedPatterm,
                  const std::unordered_set<size_t> &reducedModelExcludedEges);

private:
  void computeDesiredReducedModelDisplacements(
      const SimulationResults &fullModelResults,
      Eigen::MatrixX3d &optimalDisplacementsOfReducedModel);
  Eigen::VectorXd
  optimizeForSimulationJob(const SimulationJob &fullModelSimulationJob);
  std::vector<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);
  void initializeStiffnesses();

  static double objective(long n, const double *x);
};

#endif // REDUCEDMODELOPTIMIZER_HPP