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
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
|
/*=========================================================================
Program: ParaView
Module: vtkDataObjectToConduit.h
Copyright (c) Kitware, Inc.
All rights reserved.
See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
#ifndef CatalystAdaptor_h
#define CatalystAdaptor_h
#include "FEDataStructures.h"
#include <catalyst.hpp>
#include <iostream>
#include <string>
namespace CatalystAdaptor
{
/**
* In this example, we show how we can use Catalysts's C++
* wrapper around conduit's C API to create Conduit nodes.
* This is not required. A C++ adaptor can just as
* conveniently use the Conduit C API to setup the
* `conduit_node`. However, this example shows that one can
* indeed use Catalyst's C++ API, if the developer so chooses.
*/
void Initialize(int argc, char* argv[])
{
conduit_cpp::Node node;
for (int cc = 1; cc < argc; ++cc)
{
std::string file_path = argv[cc];
if (file_path.size() > 4 && file_path.substr(file_path.size() - 4, 4) == ".xml")
{
node["catalyst/proxies/proxy" + std::to_string(cc - 1)].set_string(argv[cc]);
}
else
{
node["catalyst/scripts/script" + std::to_string(cc - 1)].set_string(argv[cc]);
}
}
node["catalyst_load/implementation"] = "paraview";
node["catalyst_load/search_paths/paraview"] = PARAVIEW_IMPL_DIR;
catalyst_status err = catalyst_initialize(conduit_cpp::c_node(&node));
if (err != catalyst_status_ok)
{
std::cerr << "Failed to initialize Catalyst: " << err << std::endl;
}
}
void AddStateInformation(conduit_cpp::Node& exec_params, int cycle, double time)
{
// add time/cycle information
auto state = exec_params["catalyst/state"];
state["timestep"].set(cycle);
state["time"].set(time);
}
void AddGridChannel(conduit_cpp::Node& exec_params, Grid& grid, Attributes& attribs)
{
// Add channels.
// We only have 1 channel here. Let's name it 'grid'.
auto channel = exec_params["catalyst/channels/grid"];
// Since this example is using Conduit Mesh Blueprint to define the mesh,
// we set the channel's type to "mesh".
channel["type"].set("mesh");
// now create the mesh.
auto mesh = channel["data"];
// start with coordsets (of course, the sequence is not important, just make
// it easier to think in this order).
mesh["coordsets/coords/type"].set("explicit");
mesh["coordsets/coords/values/x"].set_external(
grid.GetPointsArray(), grid.GetNumberOfPoints(), /*offset=*/0, /*stride=*/3 * sizeof(double));
mesh["coordsets/coords/values/y"].set_external(grid.GetPointsArray(), grid.GetNumberOfPoints(),
/*offset=*/sizeof(double), /*stride=*/3 * sizeof(double));
mesh["coordsets/coords/values/z"].set_external(grid.GetPointsArray(), grid.GetNumberOfPoints(),
/*offset=*/2 * sizeof(double), /*stride=*/3 * sizeof(double));
// Next, add topology
mesh["topologies/mesh/type"].set("unstructured");
mesh["topologies/mesh/coordset"].set("coords");
mesh["topologies/mesh/elements/shape"].set("hex");
mesh["topologies/mesh/elements/connectivity"].set_external(
grid.GetCellPoints(0), grid.GetNumberOfCells() * 8);
// Finally, add fields.
auto fields = mesh["fields"];
fields["velocity/association"].set("vertex");
fields["velocity/topology"].set("mesh");
fields["velocity/volume_dependent"].set("false");
// velocity is stored in non-interlaced form (unlike points).
fields["velocity/values/x"].set_external(
attribs.GetVelocityArray(), grid.GetNumberOfPoints(), /*offset=*/0);
fields["velocity/values/y"].set_external(attribs.GetVelocityArray(), grid.GetNumberOfPoints(),
/*offset=*/grid.GetNumberOfPoints() * sizeof(double));
fields["velocity/values/z"].set_external(attribs.GetVelocityArray(), grid.GetNumberOfPoints(),
/*offset=*/grid.GetNumberOfPoints() * sizeof(double) * 2);
// pressure is cell-data.
fields["pressure/association"].set("element");
fields["pressure/topology"].set("mesh");
fields["pressure/volume_dependent"].set("false");
fields["pressure/values"].set_external(attribs.GetPressureArray(), grid.GetNumberOfCells());
}
void AddSteerableChannel(conduit_cpp::Node& exec_params)
{
auto steerable = exec_params["catalyst/channels/steerable"];
steerable["type"].set("mesh");
auto steerable_mesh = steerable["data"];
steerable_mesh["coordsets/coords/type"].set_string("explicit");
steerable_mesh["coordsets/coords/values/x"].set_float64_vector({ 1 });
steerable_mesh["coordsets/coords/values/y"].set_float64_vector({ 2 });
steerable_mesh["coordsets/coords/values/z"].set_float64_vector({ 3 });
steerable_mesh["topologies/mesh/type"].set("unstructured");
steerable_mesh["topologies/mesh/coordset"].set("coords");
steerable_mesh["topologies/mesh/elements/shape"].set("point");
steerable_mesh["topologies/mesh/elements/connectivity"].set_int32_vector({ 0 });
steerable_mesh["fields/steerable/association"].set("vertex");
steerable_mesh["fields/steerable/topology"].set("mesh");
steerable_mesh["fields/steerable/volume_dependent"].set("false");
steerable_mesh["fields/steerable/values"].set_int32_vector({ 2 });
}
void Execute(int cycle, double time, Grid& grid, Attributes& attribs)
{
conduit_cpp::Node exec_params;
AddStateInformation(exec_params, cycle, time);
AddGridChannel(exec_params, grid, attribs);
AddSteerableChannel(exec_params);
catalyst_status err = catalyst_execute(conduit_cpp::c_node(&exec_params));
if (err != catalyst_status_ok)
{
std::cerr << "Failed to execute Catalyst: " << err << std::endl;
}
}
void Results(unsigned int timeStep)
{
conduit_cpp::Node results;
catalyst_status err = catalyst_results(conduit_cpp::c_node(&results));
if (err != catalyst_status_ok)
{
std::cerr << "Failed to execute Catalyst: " << err << std::endl;
}
else
{
std::cout << "Result Node dump:" << std::endl;
results.print();
const std::string x_value_path = "catalyst/steerable/coordsets/coords/values/x";
if (results.has_path(x_value_path))
{
double expected_value = timeStep * 0.1;
auto node = results[x_value_path].as_float64_ptr();
if (node[0] != expected_value)
{
std::cerr << "Wrong value: " << node[0] << " expected: " << expected_value << std::endl;
}
}
else
{
std::cerr << "key: [" << x_value_path << "] not found!" << std::endl;
}
const std::string field_values_path = "catalyst/steerable/fields/type/values";
if (results.has_path(field_values_path))
{
int expected_value = timeStep % 3;
auto node = results[field_values_path].as_int_ptr();
if (node[0] != expected_value)
{
std::cerr << "Wrong value: " << node[0] << " expected: " << expected_value << std::endl;
}
}
else
{
std::cerr << "key: [" << field_values_path << "] not found!" << std::endl;
}
}
}
void Finalize()
{
conduit_cpp::Node node;
catalyst_status err = catalyst_finalize(conduit_cpp::c_node(&node));
if (err != catalyst_status_ok)
{
std::cerr << "Failed to finalize Catalyst: " << err << std::endl;
}
}
}
#endif
|
