DataContext.hpp

Go to the documentation of this file.

#pragma once
 
#include <map>
#include <optional>
#include <string>
 
#include "MappingContext.hpp"
#include "MeshContext.hpp"
#include "mapping/SharedPointer.hpp"
#include "mapping/config/MappingConfiguration.hpp"
#include "mesh/SharedPointer.hpp"
#include "mesh/Utils.hpp"
namespace precice {
 
namespace testing {
// Forward declaration to friend the boost test struct
class DataContextFixture;
} // namespace testing
 
namespace impl {

class DataContext {
  friend class testing::DataContextFixture; // Make the fixture friend of this class
public:
  std::string getDataName() const;

  void resetInitialGuesses();

  int getDataDimensions() const;

  int getSpatialDimensions() const;

  std::string getMeshName() const;

  MeshID getMeshID() const;

  bool hasGradient() const;

  int mapData(std::optional<double> after = std::nullopt, bool skipZero = false);

  virtual void appendMappingConfiguration(MappingContext &mappingContext, const MeshContext &meshContext) = 0;

  bool hasMapping() const;
 
  template <typename Container>
  std::optional<std::size_t> locateInvalidVertexID(const Container &c)
  {
    return mesh::locateInvalidVertexID(*_mesh, c);
  }

  void addJustInTimeMapping(MappingContext &mappingContext, MeshContext &meshContext);

  void initializeMappingDataCache()
  {
    if (mappingCache) {
      justInTimeMapping->initializeMappingDataCache(*mappingCache);
      mappingCache->resetData();
    }
  }

  void invalidateMappingCache()
  {
    if (mappingCache) {
      mappingCache->resetTimeStamp();
    }
  }

  void invalidateMappingCacheAndResetData()
  {
    invalidateMappingCache();
    if (mappingCache) {
      mappingCache->resetData();
    }
  }
 
protected:
  DataContext(mesh::PtrData data, mesh::PtrMesh mesh);

  std::vector<MappingContext> _mappingContexts;

  mesh::PtrData _providedData;

  std::unique_ptr<mapping::impl::MappingDataCache> mappingCache;

  mapping::PtrMapping justInTimeMapping;

  void appendMapping(MappingContext mappingContext);

  bool hasReadMapping() const;

  bool hasWriteMapping() const;

  int getMeshVertexCount() const;

  bool isValidVertexID(const VertexID id) const;
 
  mesh::PtrMesh _mesh;
 
private:
 
  static logging::Logger _log;
 
  using FromToDataIDs = std::pair<int, int>;
  std::map<FromToDataIDs, Eigen::VectorXd> _initialGuesses;
};
 
} // namespace impl
} // namespace precice