precice 3.0.1

Rust bindinds for precice
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

#include "precice-bridge.hpp"

#include <cstdlib>
#include <memory>
#include <precice/Participant.hpp>

namespace precice::rust {

// Construction

Participant::~Participant() = default;

Participant::Participant(::rust::Str participant, ::rust::Str config, rint rank, rint size)
    : participant(std::make_unique<::precice::Participant>(participant, config, rank, size))
{
}

// Steering Methods
void Participant::initialize()
{
  participant->initialize();
}
void Participant::advance(double dt)
{
  participant->advance(dt);
}
void Participant::finalize()
{
  participant->finalize();
}

// Status Queries
int Participant::get_mesh_dimensions(::rust::Str mesh_name) const
{
  return participant->getMeshDimensions(mesh_name);
}
int Participant::get_data_dimensions(::rust::Str mesh_name, ::rust::Str data_name) const
{
  return participant->getDataDimensions(mesh_name, data_name);
}
bool Participant::is_coupling_ongoing() const
{
  return participant->isCouplingOngoing();
}
bool Participant::is_time_window_complete() const
{
  return participant->isTimeWindowComplete();
}
double Participant::get_max_time_step_size() const
{
  return participant->getMaxTimeStepSize();
}

// Implicit coupling

bool Participant::requires_writing_checkpoint()
{
  return participant->requiresWritingCheckpoint();
}

bool Participant::requires_reading_checkpoint()
{
  return participant->requiresReadingCheckpoint();
}

// Mesh Access

bool Participant::requires_mesh_connectivity_for(::rust::Str mesh_name) const
{
  return participant->requiresMeshConnectivityFor(mesh_name);
}
vid Participant::set_mesh_vertex(::rust::Str mesh_name, ::rust::Slice<const double> position)
{
  return participant->setMeshVertex(mesh_name, position);
}
vid Participant::get_mesh_vertex_size(::rust::Str mesh_name) const
{
  return participant->getMeshVertexSize(mesh_name);
}
void Participant::set_mesh_vertices(::rust::Str mesh_name, ::rust::Slice<const double> positions, ::rust::Slice<vid> ids)
{
  participant->setMeshVertices(mesh_name, positions, ids);
}
void Participant::set_mesh_edge(::rust::Str mesh_name, int first_vertex_id, int second_vertex_id)
{
  return participant->setMeshEdge(mesh_name, first_vertex_id, second_vertex_id);
}
void Participant::set_mesh_edges(::rust::Str mesh_name, ::rust::Slice<const vid> vertices)
{
  participant->setMeshEdges(mesh_name, vertices);
}
void Participant::set_mesh_triangle(::rust::Str mesh_name, int first_vertex_id, int second_vertex_id, int third_vertex_id)
{
  participant->setMeshTriangle(mesh_name, first_vertex_id, second_vertex_id, third_vertex_id);
}
void Participant::set_mesh_triangles(::rust::Str mesh_name, ::rust::Slice<const vid> vertices)
{
  participant->setMeshEdges(mesh_name, vertices);
}
void Participant::set_mesh_quad(::rust::Str mesh_name, int first_vertex_id, int second_vertex_id, int third_vertex_id, int fourth_vertex_id)
{
  participant->setMeshQuad(mesh_name, first_vertex_id, second_vertex_id, third_vertex_id, fourth_vertex_id);
}
void Participant::set_mesh_quads(::rust::Str mesh_name, ::rust::Slice<const vid> vertices)
{
  participant->setMeshEdges(mesh_name, vertices);
}
void Participant::set_mesh_tetrahedron(::rust::Str mesh_name, int first_vertex_id, int second_vertex_id, int third_vertex_id, int fourth_vertex_id)
{
  participant->setMeshTetrahedron(mesh_name, first_vertex_id, second_vertex_id, third_vertex_id, fourth_vertex_id);
}
void Participant::set_mesh_tetrahedra(::rust::Str mesh_name, ::rust::Slice<const vid> vertices)
{
  participant->setMeshEdges(mesh_name, vertices);
}

// Data Access

bool Participant::requires_initial_data()
{
  return participant->requiresInitialData();
}

void Participant::write_data(::rust::Str mesh_name, ::rust::Str data_name, ::rust::Slice<const vid> vertices, ::rust::Slice<const double> values)
{
  participant->writeData(mesh_name, data_name, vertices, values);
}

void Participant::read_data(::rust::Str mesh_name, ::rust::Str data_name, ::rust::Slice<const vid> vertices, double relativeReadTime, ::rust::Slice<double> values) const
{
  participant->readData(mesh_name, data_name, vertices, relativeReadTime, values);
}

// experimental: Direct Access

void Participant::set_mesh_access_region(::rust::Str mesh_name, ::rust::Slice<const double> boundingBox)
{
  participant->setMeshAccessRegion(mesh_name, boundingBox);
}
void Participant::get_mesh_vertex_ids_and_coordinates(::rust::Str mesh_name, ::rust::Slice<vid> ids, ::rust::Slice<double> coordinates) const
{
  participant->getMeshVertexIDsAndCoordinates(mesh_name, ids, coordinates);
}

// experimental: Gradient Data

bool Participant::requires_gradient_data_for(::rust::Str mesh_name, ::rust::Str data_name) const
{
  return participant->requiresGradientDataFor(mesh_name, data_name);
}
void Participant::write_gradient_data(::rust::Str mesh_name, ::rust::Str data_name, ::rust::Slice<const vid> vertices, ::rust::Slice<const double> gradients)
{
  participant->writeGradientData(mesh_name, data_name, vertices, gradients);
}

std::unique_ptr<::precice::rust::Participant> create_participant(::rust::Str participant, ::rust::Str config, rint rank, rint size)
{
  return std::make_unique<::precice::rust::Participant>(participant, config, rank, size);
}

} // namespace precice::rust