Data.hpp

Go to the documentation of this file.

#pragma once
 
#include <Eigen/Core>
#include <initializer_list>
#include <stddef.h>
#include <string>
 
#include "SharedPointer.hpp"
#include "logging/Logger.hpp"
#include "precice/impl/Types.hpp"
#include "time/Sample.hpp"
#include "time/Time.hpp"
#include "time/Waveform.hpp"
 
namespace precice::mesh {
class Mesh;
}
 
// ----------------------------------------------------------- CLASS DEFINITION
 
namespace precice::mesh {

class Data {
public:
  // @brief Data dimensions type (scalar/vector)
  enum typeName {
    SCALAR,
    VECTOR
  };
 
  // @brief Possible types of data values.
  //  enum DataType {
  //    TYPE_UNDEFINED,
  //    TYPE_DOUBLE,
  //    TYPE_VECTOR
  //  };
 
  // @brief Name of an undefined data type.
  // static const std::string TYPE_NAME_UNDEFINED;
  // @brief Name of a double data type.
  // static const std::string TYPE_NAME_DOUBLE;
  // @brief Name of a vector data type.
  // static const std::string TYPE_NAME_VECTOR;

  Data(
      std::string name,
      DataID      id,
      int         dimension,
      int         spatialDimensions = -1,
      int         waveformDegree    = time::Time::DEFAULT_WAVEFORM_DEGREE);

  Data(
      std::string name,
      DataID      id,
      int         dimension,
      int         spatialDimensions,
      int         waveformDegree,
      std::vector<std::optional<double>>
          lowerBound,
      std::vector<std::optional<double>>
          upperBound);

  Eigen::VectorXd &values();

  const Eigen::VectorXd &values() const;

  const Eigen::MatrixXd &gradients() const;

  const time::Sample &sample() const;

  time::SampleResult sampleAtTime(double time) const;

  int getWaveformDegree() const;

  time::Waveform &waveform();
 
  std::vector<std::optional<double>> getLowerBound() const;
 
  std::vector<std::optional<double>> getUpperBound() const;
 
  void moveToNextWindow();

  auto stamples() const
  {
    return _waveform.stamples();
  }

  void setSampleAtTime(double time, const time::Sample &sample);

  void setGlobalSample(const time::Sample &sample); // @todo try to remove this function

  void emplaceSampleAtTime(double time);

  void emplaceSampleAtTime(double time, std::initializer_list<double> values);

  void emplaceSampleAtTime(double time, std::initializer_list<double> values, std::initializer_list<double> gradients);

  const std::string &getName() const;

  DataID getID() const;

  bool hasGradient() const;

  bool hasSamples() const;

  void requireDataGradient();

  int getSpatialDimensions() const;

  int getDimensions() const;

  void allocateValues(int expectedCount);
 
private:
  logging::Logger _log{"mesh::Data"};

  time::Waveform _waveform;

  std::vector<std::optional<double>> _lowerBound;

  std::vector<std::optional<double>> _upperBound;

  std::string _name;

  DataID _id;

  int _dimensions;

  int _spatialDimensions;

  bool _hasGradient = false;
 
  time::Sample _sample;
};
 
} // namespace precice::mesh