Data.cpp

Go to the documentation of this file.

#include "Data.hpp"
#include <algorithm>
#include <utility>
 
#include "math/differences.hpp"
#include "precice/impl/Types.hpp"
#include "utils/EigenHelperFunctions.hpp"
#include "utils/assertion.hpp"
 
namespace precice::mesh {
 
Data::Data(
    std::string name,
    DataID      id,
    int         dimensions,
    int         spatialDimensions,
    int         waveformDegree)
    : _waveform(waveformDegree),
      _name(std::move(name)),
      _id(id),
      _dimensions(dimensions),
      _spatialDimensions(spatialDimensions),
      _sample(_dimensions)
{
  PRECICE_ASSERT(dimensions > 0, dimensions);
}
Data::Data( {…}
 
Eigen::VectorXd &Data::values()
{
  return _sample.values;
}
Eigen::VectorXd &Data::values() {…}
 
const Eigen::VectorXd &Data::values() const
{
  return _sample.values;
}
const Eigen::VectorXd &Data::values() const {…}
 
const Eigen::MatrixXd &Data::gradients() const
{
  return _sample.gradients;
}
const Eigen::MatrixXd &Data::gradients() const {…}
 
const time::Sample &Data::sample() const
{
  return _sample;
}
const time::Sample &Data::sample() const {…}
 
time::SampleResult Data::sampleAtTime(double time) const
{
  return _waveform.sample(time);
}
time::SampleResult Data::sampleAtTime(double time) const {…}
 
int Data::getWaveformDegree() const
{
  return _waveform.timeStepsStorage().getInterpolationDegree();
}
int Data::getWaveformDegree() const {…}
 
time::Storage &Data::timeStepsStorage()
{
  return _waveform.timeStepsStorage();
}
time::Storage &Data::timeStepsStorage() {…}
 
void Data::moveToNextWindow()
{
  if (stamples().size() > 1) { // Needed to avoid CompositionalCouplingScheme callong moveToNextWindow on same Data multiple times. Could be simplified by replacing Storage::move() with clearBefore(double time). See https://github.com/precice/precice/issues/1821.
    timeStepsStorage().move();
    PRECICE_ASSERT(stamples().size() == 1);
    setGlobalSample(stamples().back().sample); // @todo at some point we should not need this anymore, when mapping, acceleration ... directly work on _timeStepsStorage, see https://github.com/precice/precice/issues/1645
  }
}
void Data::moveToNextWindow() {…}
 
void Data::setSampleAtTime(double time, const time::Sample &sample)
{
  PRECICE_ASSERT(sample.dataDims == getDimensions(), "Sample has incorrect data dimension");
  setGlobalSample(sample); // @todo at some point we should not need this anymore, when mapping, acceleration ... directly work on _timeStepsStorage, see https://github.com/precice/precice/issues/1645
  _waveform.timeStepsStorage().setSampleAtTime(time, sample);
}
void Data::setSampleAtTime(double time, const time::Sample &sample) {…}
 
void Data::setGlobalSample(const time::Sample &sample)
{
  PRECICE_ASSERT(not sample.values.hasNaN());
  _sample = sample;
}
void Data::setGlobalSample(const time::Sample &sample) {…}
 
void Data::emplaceSampleAtTime(double time)
{
  setSampleAtTime(time, time::Sample{getDimensions()});
}
void Data::emplaceSampleAtTime(double time) {…}
 
void Data::emplaceSampleAtTime(double time, std::initializer_list<double> values)
{
  setSampleAtTime(time, time::Sample{getDimensions(),
                                     Eigen::Map<const Eigen::VectorXd>(values.begin(), values.size())});
}
void Data::emplaceSampleAtTime(double time, std::initializer_list<double> values) {…}
 
void Data::emplaceSampleAtTime(double time, std::initializer_list<double> values, std::initializer_list<double> gradients)
{
  PRECICE_ASSERT(gradients.size() == values.size() * getSpatialDimensions(), "Gradient isn't correctly sized", values.size(), gradients.size());
  auto nVertices = values.size() / getDimensions();
  setSampleAtTime(time, time::Sample{getDimensions(),
                                     Eigen::Map<const Eigen::VectorXd>(values.begin(), values.size()),
                                     Eigen::Map<const Eigen::MatrixXd>(gradients.begin(), getSpatialDimensions(), nVertices * getDimensions())});
}
void Data::emplaceSampleAtTime(double time, std::initializer_list<double> values, std::initializer_list<double> gradients) {…}
 
const std::string &Data::getName() const
{
  return _name;
}
const std::string &Data::getName() const {…}
 
DataID Data::getID() const
{
  return _id;
}
DataID Data::getID() const {…}
 
bool Data::hasGradient() const
{
  return _hasGradient;
}
bool Data::hasGradient() const {…}
 
bool Data::hasSamples() const
{
  return !_waveform.stamples().empty();
}
bool Data::hasSamples() const {…}
 
void Data::requireDataGradient()
{
  _hasGradient = true;
};
void Data::requireDataGradient() {…}
 
int Data::getDimensions() const
{
  return _dimensions;
}
int Data::getDimensions() const {…}
 
void Data::allocateValues(int expectedCount)
{
  using SizeType = std::remove_cv<decltype(expectedCount)>::type;
  // Allocate data values
  const SizeType expectedSize = expectedCount * _dimensions;
  const auto     actualSize   = static_cast<SizeType>(_sample.values.size());
  // Shrink Buffer
  if (expectedSize < actualSize) {
    _sample.values.resize(expectedSize);
  }
  // Enlarge Buffer
  if (expectedSize > actualSize) {
    const auto leftToAllocate = expectedSize - actualSize;
    utils::append(_sample.values, Eigen::VectorXd(Eigen::VectorXd::Zero(leftToAllocate)));
  }
  PRECICE_DEBUG("Data {} now has {} values", _name, _sample.values.size());
 
  // Allocate gradient data values
  if (_hasGradient) {
    const SizeType spaceDimensions = _spatialDimensions;
 
    const SizeType expectedColumnSize = expectedCount * _dimensions;
    const auto     actualColumnSize   = static_cast<SizeType>(_sample.gradients.cols());
 
    // Shrink Buffer
    if (expectedColumnSize < actualColumnSize) {
      _sample.gradients.resize(spaceDimensions, expectedColumnSize);
    }
 
    // Enlarge Buffer
    if (expectedColumnSize > actualColumnSize) {
      const auto columnLeftToAllocate = expectedColumnSize - actualColumnSize;
      utils::append(_sample.gradients, Eigen::MatrixXd(Eigen::MatrixXd::Zero(spaceDimensions, columnLeftToAllocate)));
    }
    PRECICE_DEBUG("Gradient Data {} now has {} x {} values", _name, _sample.gradients.rows(), _sample.gradients.cols());
  }
}
void Data::allocateValues(int expectedCount) {…}
 
int Data::getSpatialDimensions() const
{
  return _spatialDimensions;
}
int Data::getSpatialDimensions() const {…}
 
} // namespace precice::mesh