ParticipantImpl.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <deque>
#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 "profiling/Event.hpp"
#include "utils/MultiLock.hpp"
 
namespace precice::config {
class Configuration;
} // namespace precice::config
 
// Forward declaration to friend the boost test struct
 
namespace Integration::Serial::Whitebox {
struct TestConfigurationPeano;
struct TestConfigurationComsol;
} // 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;
  };

  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
  };

  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);
 
  enum struct ExportTiming : bool {
    Advance = false,
    Initial = true
  };

  void handleExports(ExportTiming timing);

  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
  };

  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::deque<profiling::Event> _userEvents;
};
 
} // namespace impl
} // namespace precice