Mapping.hpp

Go to the documentation of this file.

#pragma once
 
#include <Eigen/Core>
#include <iosfwd>
 
#include "mesh/Mesh.hpp"
#include "mesh/SharedPointer.hpp"
 
namespace precice {
namespace mapping {
 
class Mapping {
public:
  enum Constraint {
    CONSISTENT,
    CONSERVATIVE,
    SCALED_CONSISTENT_SURFACE,
    SCALED_CONSISTENT_VOLUME
  };
 
  enum class MeshRequirement {
    UNDEFINED = 0,
    VERTEX = 1,
    FULL = 2
  };
 
  enum class InitialGuessRequirement : bool {
    Required = true,
    None     = false
  };
 
  Mapping(Constraint constraint, int dimensions, bool requiresGradientData, InitialGuessRequirement initialGuessRequirement);
 
  Mapping &operator=(Mapping &&) = delete;
 
  virtual ~Mapping() = default;
 
  void setMeshes(
      const mesh::PtrMesh &input,
      const mesh::PtrMesh &output);
 
  const mesh::PtrMesh &getInputMesh() const;
 
  const mesh::PtrMesh &getOutputMesh() const;
 
  Constraint getConstraint() const;
 
  MeshRequirement getInputRequirement() const;
 
  MeshRequirement getOutputRequirement() const;
 
  virtual void computeMapping() = 0;
 
  bool hasComputedMapping() const;
 
  virtual bool hasConstraint(const Constraint &constraint) const;
 
  bool isScaledConsistent() const;
 
  bool requiresInitialGuess() const;
 
  const Eigen::VectorXd &initialGuess() const;
 
  Eigen::VectorXd &initialGuess();
 
  bool hasInitialGuess() const;
 
  virtual void clear() = 0;
 
  void map(int inputDataID, int outputDataID);
  void map(int inputDataID, int outputDataID, Eigen::VectorXd &initialGuess);
 
  void map(const time::Sample &input, Eigen::VectorXd &output);
 
  void map(const time::Sample &input, Eigen::VectorXd &output, Eigen::VectorXd &initialGuess);
 
  virtual void tagMeshFirstRound() = 0;
 
  virtual void tagMeshSecondRound() = 0;
 
  virtual void scaleConsistentMapping(const Eigen::VectorXd &input, Eigen::VectorXd &output, Constraint type) const;
 
  bool requiresGradientData() const;
 
  virtual std::string getName() const = 0;
 
protected:
  mesh::PtrMesh input() const;
 
  mesh::PtrMesh output() const;
 
  void setInputRequirement(MeshRequirement requirement);
 
  void setOutputRequirement(MeshRequirement requirement);
 
  int getDimensions() const;
 
  bool _hasComputedMapping = false;
 
  bool _requiresGradientData;
 
  virtual void mapConservative(const time::Sample &input, Eigen::VectorXd &output) = 0;
  virtual void mapConsistent(const time::Sample &input, Eigen::VectorXd &output) = 0;
 
private:
  Constraint _constraint;
 
  MeshRequirement _inputRequirement;
 
  MeshRequirement _outputRequirement;
 
  mesh::PtrMesh _input;
 
  mesh::PtrMesh _output;
 
  int _dimensions;
 
  InitialGuessRequirement _initialGuessRequirement;
 
  Eigen::VectorXd *_initialGuess = nullptr;
};
 
bool operator<(Mapping::MeshRequirement lhs, Mapping::MeshRequirement rhs);
 
std::ostream &operator<<(std::ostream &out, Mapping::MeshRequirement val);
 
} // namespace mapping
} // namespace precice