MappingDataCache.hpp

Go to the documentation of this file.

#pragma once
 
#include <Eigen/Core>
#include "mapping/SharedPointer.hpp"
#include "mesh/Mesh.hpp"
#include "precice/impl/Types.hpp"
#include "time/Sample.hpp"
 
namespace precice {
namespace mapping {
namespace impl {
 
struct MappingDataCache {
public:
  explicit MappingDataCache(int dataDim);
 
  // The inData member is for basic mappings (such as NN) and simply stores
  // the latest evaluation of the waveform relaxation to prevent repeated time
  // interpolation
  time::Stample inData;
 
  // The std::vector<> member variables here are specific to PUM:
  // we store cache data for each cluster:
  // We need a sequence of polynomial contributions
  // all data here is stored as a Matrix to encode the number of components
  // the layout is
  // Eigen::MatrixXd (vertices, components);
  // Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor, Eigen::Dynamic, 3> instead of MatrixXd?
  // an alternative layout of this data could be to wrap this in another struct ClusterData which is then within a vector
  std::vector<Eigen::MatrixXd> polynomialContributions;
  // ...and a vector of P/lambdas (the RBF coefficients)
  // For conservative mappings, this vector refers to the Au, potentially as vector components
  std::vector<Eigen::MatrixXd> p;
 
  int getDataDimensions() const;
 
  bool hasDataAtTimeStamp(double time) const;
 
  void setTimeStamp(double time);
 
  void resetTimeStamp();
 
  void resetData();
};
struct MappingDataCache {…};
 
// ------------------------------------------------------ HEADER IMPLEMENTATION
inline MappingDataCache::MappingDataCache(int dataDim)
    : inData{-1, time::Sample(dataDim)}
{
}
inline MappingDataCache::MappingDataCache(int dataDim) {…}
 
inline int MappingDataCache::getDataDimensions() const
{
  return inData.sample.dataDims;
}
inline int MappingDataCache::getDataDimensions() const {…}
 
inline bool MappingDataCache::hasDataAtTimeStamp(double time) const
{
  return math::equals(inData.timestamp, time);
}
inline bool MappingDataCache::hasDataAtTimeStamp(double time) const {…}
 
inline void MappingDataCache::setTimeStamp(double time)
{
  inData.timestamp = time;
}
inline void MappingDataCache::setTimeStamp(double time) {…}
 
inline void MappingDataCache::resetTimeStamp()
{
  // Set the timestamp to -1, which is invalid anyway, since the time simulation time can only be positive
  inData.timestamp = -1;
}
inline void MappingDataCache::resetTimeStamp() {…}
 
inline void MappingDataCache::resetData()
{
  inData.sample.setZero();
 
  for (auto &mat : polynomialContributions) {
    mat.setZero();
  }
  for (auto &mat : p) {
    mat.setZero();
  }
}
inline void MappingDataCache::resetData() {…}
} // namespace impl
} // namespace mapping
} // namespace precice