ParticipantState.hpp

Go to the documentation of this file.

#pragma once
 
#include <boost/range/adaptor/map.hpp>
#include <cmath>
#include <memory>
#include <stddef.h>
#include <string>
#include <string_view>
#include <utility>
#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/ReadDataContext.hpp"
#include "precice/impl/Types.hpp"
#include "precice/impl/WriteDataContext.hpp"
#include "utils/IntraComm.hpp"
#include "utils/ManageUniqueIDs.hpp"
 
namespace precice {
namespace impl {
struct MeshContext;
struct MappingContext;
} // namespace impl
} // namespace precice
 
// Forward declaration to friend the boost test struct
namespace Integration {
namespace Serial {
namespace Whitebox {
struct TestConfigurationPeano;
struct TestConfigurationComsol;
} // namespace Whitebox
} // namespace Serial
} // namespace Integration
 
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);
 
  virtual ~ParticipantState();
 
  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 setMeshIdManager(std::unique_ptr<utils::ManageUniqueIDs> &&idm)
  {
    _meshIdManager = std::move(idm);
  }
 
  void addAction(action::PtrAction &&action);
 
  void addExportContext(const io::ExportContext &context);
 
  void provideMesh(const mesh::PtrMesh &mesh);
 
  void receiveMesh(const 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<MeshContext *> &usedMeshContexts() const;
 
  std::vector<MeshContext *> &usedMeshContexts();
 
  MeshContext &usedMeshContext(std::string_view name);
 
  MeshContext const &usedMeshContext(std::string_view name) const;
 
  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;
 
  void exportInitial();
 
  struct IntermediateExport {
    size_t timewindow;
    size_t iteration;
    double time;
    bool   complete;
  };
 
  void exportIntermediate(IntermediateExport exp);
 
 
  const std::string &getName() const;
 
  bool useIntraComm() 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;
 
  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::vector<MappingContext> _readMappingContexts;
 
  std::vector<MappingContext> _writeMappingContexts;
 
  std::vector<MeshContext *> _usedMeshContexts;
 
  DataMap<WriteDataContext> _writeDataContexts;
 
  DataMap<ReadDataContext> _readDataContexts;
 
  bool _useIntraComm = false;
 
  std::unique_ptr<utils::ManageUniqueIDs> _meshIdManager;
 
  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