ParticipantState.hpp

Go to the documentation of this file.

#pragma once
 
#include <boost/range/adaptor/map.hpp>
#include <cmath>
#include <deque>
#include <memory>
#include <stddef.h>
#include <string>
#include <string_view>
#include <utility>
#include <variant>
#include <vector>
 
#include "SharedPointer.hpp"
#include "action/SharedPointer.hpp"
#include "cplscheme/SharedPointer.hpp"
#include "io/ExportContext.hpp"
#include "io/config/ExportConfiguration.hpp"
#include "logging/Logger.hpp"
#include "mapping/SharedPointer.hpp"
#include "mesh/SharedPointer.hpp"
#include "partition/ReceivedPartition.hpp"
#include "precice/impl/MeshContext.hpp"
#include "precice/impl/ProvidedMeshContext.hpp"
#include "precice/impl/ReadDataContext.hpp"
#include "precice/impl/ReceivedMeshContext.hpp"
#include "precice/impl/Types.hpp"
#include "precice/impl/WriteDataContext.hpp"
#include "utils/IntraComm.hpp"
#include "utils/ManageUniqueIDs.hpp"
 
namespace precice::impl {

using MeshContextVariant = std::variant<ProvidedMeshContext *, ReceivedMeshContext *>;

inline MeshContext *getMeshContext(const MeshContextVariant &variant)
{
  return std::visit([](auto *p) -> MeshContext * { return p; }, variant);
}

inline mesh::Mesh &getMesh(const MeshContextVariant &variant)
{
  return std::visit([](auto *p) -> mesh::Mesh & { return *p->mesh; }, variant);
}

inline partition::Partition &getPartition(const MeshContextVariant &variant)
{
  return std::visit([](auto *p) -> partition::Partition & { return *p->partition; }, variant);
}
 
struct MappingContext;
} // namespace precice::impl
 
// Forward declaration to friend the boost test struct
 
namespace Integration::Serial::Whitebox {
struct TestConfigurationPeano;
struct TestConfigurationComsol;
} // namespace Integration::Serial::Whitebox
 
namespace precice {
namespace utils {
class ManageUniqueIDs;
} // namespace utils
 
namespace impl {

template <typename T>
struct MeshDataKey {
  T mesh;
  T data;
  template <typename Other>
  bool operator<(const MeshDataKey<Other> &other) const
  {
    if (mesh < other.mesh) {
      return true;
    }
    if (other.mesh < mesh) {
      return false;
    }
    return data < other.data;
  }
};

template <class T>
MeshDataKey(T, T) -> MeshDataKey<T>;

class ParticipantState {
public:
  enum MappingConstants {
    MAPPING_LINEAR_CONSERVATIVE,
    MAPPING_LINEAR_CONSISTENT,
    MAPPING_DIRECT
  };

  ParticipantState(
      std::string                 name,
      mesh::PtrMeshConfiguration &meshConfig);

  void addWriteData(
      const mesh::PtrData &data,
      const mesh::PtrMesh &mesh);

  void addReadData(
      const mesh::PtrData &data,
      const mesh::PtrMesh &mesh);

  void addReadMappingContext(const MappingContext &mappingContext);

  void addWriteMappingContext(const MappingContext &mappingContext);

  void addWatchPoint(const PtrWatchPoint &watchPoint);

  void addWatchIntegral(const PtrWatchIntegral &watchIntegral);

  void setUsePrimaryRank(bool useIntraComm);

  void addAction(action::PtrAction &&action);

  void addExportContext(const io::ExportContext &context);

  void provideMesh(mesh::PtrMesh mesh);

  void receiveMesh(mesh::PtrMesh                                 mesh,
                   const std::string                            &fromParticipant,
                   double                                        safetyFactor,
                   partition::ReceivedPartition::GeometricFilter geoFilter,
                   const bool                                    allowDirectAccess);


  const ReadDataContext &readDataContext(std::string_view mesh, std::string_view data) const;

  ReadDataContext &readDataContext(std::string_view mesh, std::string_view data);

  mesh::PtrMesh findMesh(std::string_view data) const;

  const WriteDataContext &writeDataContext(std::string_view mesh, std::string_view data) const;

  WriteDataContext &writeDataContext(std::string_view mesh, std::string_view data);

  auto writeDataContexts()
  {
    return _writeDataContexts | boost::adaptors::map_values;
  }

  auto readDataContexts()
  {
    return _readDataContexts | boost::adaptors::map_values;
  }

  bool hasData(std::string_view mesh, std::string_view data) const;

  bool isDataUsed(std::string_view mesh, std::string_view data) const;

  bool isDataRead(std::string_view mesh, std::string_view data) const;

  bool isDataWrite(std::string_view mesh, std::string_view data) const;

  /*** Provides direct access to a \ref MeshContext given the \ref meshid
   * @param[in] meshID the id of the \ref Mesh
   * @returns a reference to the matching \ref MeshContext
   * @pre the \ref Mesh with \ref meshID is used by the ParticipantState
   */
  const MeshContext &meshContext(std::string_view mesh) const;
 
  /*** Provides direct access to a \ref MeshContext given the \ref meshid
   * @param[in] meshID the id of the \ref Mesh
   * @returns a reference to the matching \ref MeshContext
   * @pre the \ref Mesh with \ref meshID is used by the ParticipantState
   */
  MeshContext &meshContext(std::string_view mesh);

  const std::vector<MeshContextVariant> &usedMeshContexts() const;

  std::vector<MeshContextVariant> &usedMeshContexts();

  bool hasMesh(std::string_view mesh) const;

  bool isMeshUsed(std::string_view mesh) const;

  bool isMeshProvided(std::string_view mesh) const;

  bool isMeshReceived(std::string_view mesh) const;

  bool isDirectAccessAllowed(std::string_view mesh) const;

  ReceivedMeshContext &receivedMeshContext(std::string_view mesh);

  const ReceivedMeshContext &receivedMeshContext(std::string_view mesh) const;

  ProvidedMeshContext &providedMeshContext(std::string_view mesh);

  const ProvidedMeshContext &providedMeshContext(std::string_view mesh) const;

  std::deque<ProvidedMeshContext> &providedMeshContexts();

  const std::deque<ProvidedMeshContext> &providedMeshContexts() const;

  std::deque<ReceivedMeshContext> &receivedMeshContexts();

  const std::deque<ReceivedMeshContext> &receivedMeshContexts() const;

  void initializeMappingDataCache(std::string_view mappingType);

  void configureInputMeshContext(std::string_view fromMesh, impl::MappingContext &mappingContext, mapping::Mapping::MeshRequirement requirement);

  void configureOutputMeshContext(std::string_view toMesh, impl::MappingContext &mappingContext, mapping::Mapping::MeshRequirement requirement);

  void exportInitial();
 
  struct IntermediateExport {
    size_t timewindow;
    size_t iteration;
    double time;
    bool   complete;
    bool   final;
  };

  void exportIntermediate(IntermediateExport exp);


  const std::string &getName() const;

  bool useIntraComm() const;

  bool hasReadMappings() const;

  bool hasWriteMappings() const;

  std::vector<MappingContext> &readMappingContexts();

  std::vector<MappingContext> &writeMappingContexts();

  std::vector<PtrWatchPoint> &watchPoints();

  std::vector<PtrWatchIntegral> &watchIntegrals();

  std::vector<action::PtrAction> &actions();

  const std::vector<action::PtrAction> &actions() const;

  const std::vector<io::ExportContext> &exportContexts() const;

  bool hasExports() const;

  std::string hintForMesh(std::string_view mesh) const;
  std::string hintForMeshData(std::string_view mesh, std::string_view data) const;
 
private:
  mutable logging::Logger _log{"impl::ParticipantState"};
 
  std::string _name;
 
  std::vector<PtrWatchPoint> _watchPoints;
 
  std::vector<PtrWatchIntegral> _watchIntegrals;

  std::vector<io::ExportContext> _exportContexts;
 
  std::vector<action::PtrAction> _actions;
 
  template <typename T>
  using MeshMap = std::map<std::string, T, std::less<>>;
 
  template <typename T>
  using DataMap = std::map<MeshDataKey<std::string>, T, std::less<>>;

  MeshMap<MeshContext *> _meshContexts;

  std::deque<ProvidedMeshContext> _providedMeshContexts;

  std::deque<ReceivedMeshContext> _receivedMeshContexts;

  std::vector<MappingContext> _readMappingContexts;

  std::vector<MappingContext> _writeMappingContexts;

  std::vector<MeshContextVariant> _usedMeshContexts;
 
  DataMap<WriteDataContext> _writeDataContexts;
 
  DataMap<ReadDataContext> _readDataContexts;
 
  bool _useIntraComm = false;
 
  template <typename ELEMENT_T>
  bool isDataValid(
      const std::vector<ELEMENT_T> &data,
      const ELEMENT_T              &newElement) const;
 
  void checkDuplicatedUse(std::string_view mesh);
 
  void checkDuplicatedData(std::string_view mesh, std::string_view data);

  friend struct Integration::Serial::Whitebox::TestConfigurationPeano;
  friend struct Integration::Serial::Whitebox::TestConfigurationComsol;
};
 
// --------------------------------------------------------- HEADER DEFINITIONS
 
template <typename ELEMENT_T>
bool ParticipantState::isDataValid(
    const std::vector<ELEMENT_T> &data,
    const ELEMENT_T              &newElement) const
{
  for (size_t i = 0; i < data.size(); i++) {
    if (data[i].name == newElement.name) {
      return false;
    }
  }
  return true;
}
 
} // namespace impl
} // namespace precice