ParticipantImpl.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <map>
#include <set>
#include <string>
#include <string_view>
#include <vector>
 
#include "action/Action.hpp"
#include "boost/noncopyable.hpp"
#include "com/Communication.hpp"
#include "cplscheme/CouplingScheme.hpp"
#include "cplscheme/SharedPointer.hpp"
#include "logging/Logger.hpp"
#include "m2n/BoundM2N.hpp"
#include "m2n/config/M2NConfiguration.hpp"
#include "precice/Participant.hpp"
#include "precice/impl/DataContext.hpp"
#include "precice/impl/SharedPointer.hpp"
#include "precice/impl/Types.hpp"
#include "utils/MultiLock.hpp"
 
namespace precice {
 
namespace profiling {
class Event;
}
namespace profiling {…}
 
namespace config {
class Configuration;
}
} // namespace precice
 
// Forward declaration to friend the boost test struct
 
namespace Integration::Serial::Whitebox {
struct TestConfigurationPeano;
struct TestConfigurationComsol;
} // namespace Integration::Serial::Whitebox
namespace Integration::Serial::Whitebox {…}
 
namespace precice {
namespace cplscheme {
class CouplingSchemeConfiguration;
} // namespace cplscheme
namespace mesh {
class Mesh;
} // namespace mesh
 
namespace impl {
 
class ParticipantImpl {
public:
 
  ParticipantImpl(
      std::string_view      participantName,
      std::string_view      configurationFileName,
      int                   solverProcessIndex,
      int                   solverProcessSize,
      std::optional<void *> communicator);
 
  ~ParticipantImpl();
 
 
 
  void initialize();
 
  void advance(double computedTimeStepSize);
 
  void finalize();
 
 
 
  int getMeshDimensions(std::string_view meshName) const;
 
  int getDataDimensions(std::string_view meshName, std::string_view dataName) const;
 
  bool isCouplingOngoing() const;
 
  bool isTimeWindowComplete() const;
 
  double getMaxTimeStepSize() const;
 
 
 
  bool requiresInitialData();
 
  bool requiresReadingCheckpoint();
 
  bool requiresWritingCheckpoint();
 
 
 
  void resetMesh(std::string_view meshName);
 
  bool requiresMeshConnectivityFor(std::string_view meshName) const;
 
  bool requiresGradientDataFor(std::string_view meshName,
                               std::string_view dataName) const;
 
  VertexID setMeshVertex(
      std::string_view              meshName,
      ::precice::span<const double> position);
 
  int getMeshVertexSize(std::string_view meshName) const;
 
  void setMeshVertices(
      std::string_view              meshName,
      ::precice::span<const double> positions,
      ::precice::span<VertexID>     ids);
 
  void setMeshEdge(
      std::string_view meshName,
      VertexID         first,
      VertexID         second);
 
  void setMeshEdges(
      std::string_view                meshName,
      ::precice::span<const VertexID> vertices);
 
  void setMeshTriangle(
      std::string_view meshName,
      VertexID         first,
      VertexID         second,
      VertexID         third);
 
  void setMeshTriangles(
      std::string_view                meshName,
      ::precice::span<const VertexID> vertices);
 
  void setMeshQuad(
      std::string_view meshName,
      VertexID         first,
      VertexID         second,
      VertexID         third,
      VertexID         fourth);
 
  void setMeshQuads(
      std::string_view                meshName,
      ::precice::span<const VertexID> vertices);
 
  void setMeshTetrahedron(
      std::string_view meshName,
      VertexID         first,
      VertexID         second,
      VertexID         third,
      VertexID         fourth);
 
  void setMeshTetrahedra(
      std::string_view                meshName,
      ::precice::span<const VertexID> vertices);
 
 
 
  void readData(
      std::string_view                meshName,
      std::string_view                dataName,
      ::precice::span<const VertexID> vertices,
      double                          relativeReadTime,
      ::precice::span<double>         values) const;
 
  void mapAndReadData(
      std::string_view              meshName,
      std::string_view              dataName,
      ::precice::span<const double> coordinates,
      double                        relativeReadTime,
      ::precice::span<double>       values) const;
 
  void writeAndMapData(
      std::string_view              meshName,
      std::string_view              dataName,
      ::precice::span<const double> coordinates,
      ::precice::span<const double> values);
 
  void writeData(
      std::string_view                meshName,
      std::string_view                dataName,
      ::precice::span<const VertexID> vertices,
      ::precice::span<const double>   values);
 
  void writeGradientData(
      std::string_view                meshName,
      std::string_view                dataName,
      ::precice::span<const VertexID> vertices,
      ::precice::span<const double>   gradients);
 
 
 
  void setMeshAccessRegion(std::string_view              meshName,
                           ::precice::span<const double> boundingBox) const;
 
  void getMeshVertexIDsAndCoordinates(
      std::string_view          meshName,
      ::precice::span<VertexID> ids,
      ::precice::span<double>   coordinates) const;
 
 
 
  void startProfilingSection(std::string_view eventName);
 
  void stopLastProfilingSection();
 
 
  const mesh::Mesh &mesh(const std::string &meshName) const;
 
  struct MappedSamples {
    int write, read;
  };
  struct MappedSamples {…};
 
  MappedSamples mappedSamples() const;
 
  ParticipantImpl(ParticipantImpl const &) = delete;
 
  ParticipantImpl &operator=(ParticipantImpl const &) = delete;
 
  ParticipantImpl(ParticipantImpl &&) = delete;
 
  ParticipantImpl &operator=(ParticipantImpl &&) = delete;
 
private:
  mutable logging::Logger _log{"impl::ParticipantImpl"};
 
  std::string _accessorName;
 
  int _accessorProcessRank;
 
  int _accessorCommunicatorSize;
 
  impl::PtrParticipant _accessor;
 
  int _dimensions = 0;
 
  utils::MultiLock<std::string> _meshLock;
 
  std::map<std::string, int> _meshIDs;
 
  std::map<std::string, m2n::BoundM2N> _m2ns;
 
  std::vector<impl::PtrParticipant> _participants;
 
  cplscheme::PtrCouplingScheme _couplingScheme;
 
  enum struct State {
    Constructed, // Initial state of Participant
    Initialized, // Participant.initialize() triggers transition from State::Constructed to State::Initialized; mandatory
    Finalized    // Participant.finalize() triggers transition form State::Initialized to State::Finalized; mandatory
  };
  enum struct State {…};
 
  bool _allowsExperimental = false;
 
  bool _allowsRemeshing = false;
 
  bool _waitInFinalize = false;
 
  State _state{State::Constructed};
 
  long int _numberAdvanceCalls = 0;
 
  int _executedWriteMappings = 0;
 
  int _executedReadMappings = 0;
 
  std::string _configHash;
 
  void configure(std::string_view configurationFileName);
 
  void configure(const config::Configuration &configuration);
 
  void configureM2Ns(const m2n::M2NConfiguration::SharedPointer &config);
 
  enum struct ExportTiming : bool {
    Advance = false,
    Initial = true
  };
  enum struct ExportTiming : bool {…};
 
  void handleExports(ExportTiming timing);
 
  void configurePartitions(
      const m2n::M2NConfiguration::SharedPointer &m2nConfig);
 
  void compareBoundingBoxes();
 
  void computePartitions();
 
  void computeMappings(std::vector<MappingContext> &contexts, const std::string &mappingType);
 
  void mapInitialWrittenData();
 
  void mapWrittenData(std::optional<double> after = std::nullopt);
 
  // Computes, and performs read mappings of the initial data in initialize
  void mapInitialReadData();
 
  // Computes, and performs read mappings
  void mapReadData();
 
  void trimReadMappedData(double timeAfterAdvance, bool isTimeWindowComplete, const cplscheme::ImplicitData &fromData);
 
  void performDataActions(const std::set<action::Action::Timing> &timings);
 
  void resetWrittenData(); // bool isAtWindowEnd, bool isTimeWindowComplete);
 
  impl::PtrParticipant determineAccessingParticipant(
      const config::Configuration &config);
 
  void initializeIntraCommunication();
 
  void advanceCouplingScheme();
 
  void syncTimestep(double computedTimeStepSize);
 
  enum class CloseChannels : bool {
    All         = false,
    Distributed = true
  };
  enum class CloseChannels : bool {…};
 
  void closeCommunicationChannels(CloseChannels cc);
 
  void handleDataBeforeAdvance(bool reachedTimeWindowEnd, double timeSteppedTo);
 
  void handleDataAfterAdvance(bool reachedTimeWindowEnd, bool isTimeWindowComplete, double timeSteppedTo, double timeAfterAdvance, const cplscheme::ImplicitData &receivedData);
 
  void samplizeWriteData(double time);
 
  void trimOldDataBefore(double time);
 
  void trimSendDataAfter(double time);
 
  using MeshChanges = std::vector<int>;
 
  MeshChanges getTotalMeshChanges() const;
 
  void clearStamplesOfChangedMeshes(MeshChanges totalMeshChanges);
 
  bool reinitHandshake(bool requestReinit) const;
 
  void reinitialize();
 
  void setupCommunication();
 
  void setupWatcher();
 
  bool requiresUserDefinedAccessRegion(std::string_view meshName) const;
 
  friend struct Integration::Serial::Whitebox::TestConfigurationPeano;
  friend struct Integration::Serial::Whitebox::TestConfigurationComsol;
 
  std::unique_ptr<profiling::Event> _solverInitEvent;
  std::unique_ptr<profiling::Event> _solverAdvanceEvent;
 
  std::vector<profiling::Event> _userEvents;
};
class ParticipantImpl {…};
 
} // namespace impl
} // namespace precice