Mapping.hpp

Go to the documentation of this file.

#pragma once
 
#include <Eigen/Core>
#include <iosfwd>
 
#include "mapping/impl/MappingDataCache.hpp"
#include "mesh/Mesh.hpp"
#include "mesh/SharedPointer.hpp"
#include "precice/span.hpp"
 
namespace precice::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;

  bool isJustInTimeMapping() 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;

  virtual void mapConservativeAt(const Eigen::Ref<const Eigen::MatrixXd> &coordinates, const Eigen::Ref<const Eigen::MatrixXd> &source, impl::MappingDataCache &cache, Eigen::Ref<Eigen::MatrixXd> target);

  virtual void mapConsistentAt(const Eigen::Ref<const Eigen::MatrixXd> &coordinates, const impl::MappingDataCache &cache, Eigen::Ref<Eigen::MatrixXd> values);

  virtual void updateMappingDataCache(impl::MappingDataCache &cache, const Eigen::Ref<const Eigen::VectorXd> &in);

  virtual void initializeMappingDataCache(impl::MappingDataCache &cache);

  virtual void completeJustInTimeMapping(impl::MappingDataCache &cache, Eigen::Ref<Eigen::MatrixXd> result);
 
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 precice::mapping