Shamrock 2025.10.0
Astrophysical Code
Loading...
Searching...
No Matches
CartesianRender.cpp
Go to the documentation of this file.
1// -------------------------------------------------------//
2//
3// SHAMROCK code for hydrodynamics
4// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
5// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
6// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
7//
8// -------------------------------------------------------//
9
17
18#include "shambase/exception.hpp"
19#include "shambackends/kernel_call.hpp"
20#include "shammath/AABB.hpp"
21#include "shammodels/sph/modules/render/CartesianRender.hpp"
22#include "shammodels/sph/modules/render/RenderFieldGetter.hpp"
23#include "shammodels/sph/modules/render/SPHAzymuthalInteg.hpp"
24#include "shammodels/sph/modules/render/SPHColumnInteg.hpp"
25#include "shammodels/sph/modules/render/SPHInterpolation.hpp"
26#include "shamrock/solvergraph/DeviceBufferEdge.hpp"
27#include "shamrock/solvergraph/Field.hpp"
28#include "shamrock/solvergraph/FieldRefs.hpp"
29#include "shamrock/solvergraph/Indexes.hpp"
30#include "shamsolvergraph/edge/IDataEdge.hpp"
31
32namespace shammodels::sph::modules {
33
34 template<class Tvec>
35 sham::DeviceBuffer<Tvec> pixel_to_positions(
36 Tvec center, Tvec delta_x, Tvec delta_y, u32 nx, u32 ny) {
37
38 sham::DeviceBuffer<Tvec> ret{nx * ny, shamsys::instance::get_compute_scheduler_ptr()};
39
40 sham::DeviceQueue &q = shamsys::instance::get_compute_scheduler().get_queue();
41
42 sham::kernel_call(
43 q, sham::MultiRef{}, sham::MultiRef{ret}, nx * ny, [=](u32 gid, Tvec *position) {
44 u32 ix = gid % nx;
45 u32 iy = gid / nx;
46 f64 fx = ((f64(ix) + 0.5) / nx) - 0.5;
47 f64 fy = ((f64(iy) + 0.5) / ny) - 0.5;
48 position[gid] = center + delta_x * fx + delta_y * fy;
49 });
50
51 return ret;
52 }
53
54 template<class Tvec>
55 sham::DeviceBuffer<shammath::Ray<Tvec>> pixel_to_orthographic_rays(
56 Tvec center, Tvec delta_x, Tvec delta_y, u32 nx, u32 ny) {
57
58 using Tscal = shambase::VecComponent<Tvec>;
59
60 sham::DeviceBuffer<shammath::Ray<Tvec>> ret{
61 nx * ny, shamsys::instance::get_compute_scheduler_ptr()};
62
63 sham::DeviceQueue &q = shamsys::instance::get_compute_scheduler().get_queue();
64
65 Tvec e_z = sycl::cross(delta_x, delta_y);
66 Tscal len = sycl::length(e_z);
67 if (!(len > 0)) {
68 throw shambase::make_except_with_loc<std::invalid_argument>(sham::format(
69 "The cross product of delta_x and delta_y is zero\n"
70 " args :"
71 " center = {}\n"
72 " delta_x = {}\n"
73 " delta_y = {}\n"
74 " nx = {}\n"
75 " ny = {}\n"
76 " -> e_z = {}\n",
77 center,
78 delta_x,
79 delta_y,
80 nx,
81 ny,
82 e_z));
83 }
84 e_z /= len;
85
86 sham::kernel_call(
87 q,
88 sham::MultiRef{},
89 sham::MultiRef{ret},
90 nx * ny,
91 [=](u32 gid, shammath::Ray<Tvec> *ray) {
92 u32 ix = gid % nx;
93 u32 iy = gid / nx;
94 f64 fx = ((f64(ix) + 0.5) / nx) - 0.5;
95 f64 fy = ((f64(iy) + 0.5) / ny) - 0.5;
96 Tvec pos_render = center + delta_x * fx + delta_y * fy;
97
98 ray[gid] = shammath::Ray<Tvec>(pos_render, e_z);
99 });
100
101 return ret;
102 }
103
104 template<class Tvec, class Tfield, template<class> class SPHKernel>
105 auto CartesianRender<Tvec, Tfield, SPHKernel>::compute_slice(
106 std::string field_name,
107 const sham::DeviceBuffer<Tvec> &positions,
108 std::optional<std::function<py::array_t<Tfield>(size_t, shamrock::PatchDataLazyGetter &)>>
109 custom_getter) -> sham::DeviceBuffer<Tfield> {
110
111 if (shamcomm::world_rank() == 0) {
112 logger::info_ln(
113 "sph::CartesianRender",
114 sham::format(
115 "compute_slice field_name: {}, positions count: {}",
116 field_name,
117 positions.get_size()));
118 }
119
120 shambase::Timer t;
121 t.start();
122
123 auto ret = RenderFieldGetter<Tvec, Tfield, SPHKernel>(context, solver_config, storage)
124 .runner_function(
125 field_name,
126 [&](auto field_getter) -> sham::DeviceBuffer<Tfield> {
127 return compute_slice(field_getter, positions);
128 },
129 custom_getter);
130
131 t.stop();
132 if (shamcomm::world_rank() == 0) {
133 logger::info_ln(
134 "sph::CartesianRender", sham::format("compute_slice took {}", t.get_time_str()));
135 }
136
137 return ret;
138 }
139
140 template<class Tvec, class Tfield, template<class> class SPHKernel>
141 auto CartesianRender<Tvec, Tfield, SPHKernel>::compute_slice(
142 shamrock::solvergraph::Field<Tfield> &field, const sham::DeviceBuffer<Tvec> &positions)
143 -> sham::DeviceBuffer<Tfield> {
144
145 if (field.get_nvar() != 1) {
146 throw shambase::make_except_with_loc<std::invalid_argument>(
147 "render only supports fields with nvar == 1");
148 }
149
150 shambase::DistributedData<u32> sizes{};
151 scheduler().for_each_patchdata_nonempty(
152 [&](const shamrock::patch::Patch p, shamrock::patch::PatchDataLayer &pdat) {
153 sizes.add_obj(p.id_patch, pdat.get_obj_cnt());
154 });
155 field.check_sizes(sizes);
156
157 auto field_getter
158 = [&](const shamrock::patch::Patch cur_p,
159 shamrock::patch::PatchDataLayer &pdat) -> const sham::DeviceBuffer<Tfield> & {
160 return field.get_buf(cur_p.id_patch);
161 };
162
163 return compute_slice(field_getter, positions);
164 }
165
166 template<class Tvec, class Tfield, template<class> class SPHKernel>
167 auto CartesianRender<Tvec, Tfield, SPHKernel>::compute_column_integ(
168 std::string field_name,
169 const sham::DeviceBuffer<shammath::Ray<Tvec>> &rays,
170 std::optional<std::function<py::array_t<Tfield>(size_t, shamrock::PatchDataLazyGetter &)>>
171 custom_getter) -> sham::DeviceBuffer<Tfield> {
172
173 if (shamcomm::world_rank() == 0) {
174 logger::info_ln(
175 "sph::CartesianRender",
176 sham::format(
177 "compute_column_integ field_name: {}, rays count: {}",
178 field_name,
179 rays.get_size()));
180 }
181
182 shambase::Timer t;
183 t.start();
184
185 auto ret = RenderFieldGetter<Tvec, Tfield, SPHKernel>(context, solver_config, storage)
186 .runner_function(
187 field_name,
188 [&](auto field_getter) -> sham::DeviceBuffer<Tfield> {
189 return compute_column_integ(field_getter, rays);
190 },
191 custom_getter);
192
193 t.stop();
194 if (shamcomm::world_rank() == 0) {
195 logger::info_ln(
196 "sph::CartesianRender",
197 sham::format("compute_column_integ took {}", t.get_time_str()));
198 }
199
200 return ret;
201 }
202
203 template<class Tvec, class Tfield, template<class> class SPHKernel>
204 auto CartesianRender<Tvec, Tfield, SPHKernel>::compute_column_integ(
205 shamrock::solvergraph::Field<Tfield> &field,
206 const sham::DeviceBuffer<shammath::Ray<Tvec>> &rays) -> sham::DeviceBuffer<Tfield> {
207
208 if (field.get_nvar() != 1) {
209 throw shambase::make_except_with_loc<std::invalid_argument>(
210 "render only supports fields with nvar == 1");
211 }
212
213 shambase::DistributedData<u32> sizes{};
214 scheduler().for_each_patchdata_nonempty(
215 [&](const shamrock::patch::Patch p, shamrock::patch::PatchDataLayer &pdat) {
216 sizes.add_obj(p.id_patch, pdat.get_obj_cnt());
217 });
218 field.check_sizes(sizes);
219
220 auto field_getter
221 = [&](const shamrock::patch::Patch cur_p,
222 shamrock::patch::PatchDataLayer &pdat) -> const sham::DeviceBuffer<Tfield> & {
223 return field.get_buf(cur_p.id_patch);
224 };
225
226 return compute_column_integ(field_getter, rays);
227 }
228
229 template<class Tvec, class Tfield, template<class> class SPHKernel>
230 auto CartesianRender<Tvec, Tfield, SPHKernel>::compute_azymuthal_integ(
231 std::string field_name,
232 const sham::DeviceBuffer<shammath::RingRay<Tvec>> &ring_rays,
233 std::optional<std::function<py::array_t<Tfield>(size_t, shamrock::PatchDataLazyGetter &)>>
234 custom_getter) -> sham::DeviceBuffer<Tfield> {
235
236 if (shamcomm::world_rank() == 0) {
237 logger::info_ln(
238 "sph::CartesianRender",
239 sham::format(
240 "compute_azymuthal_integ field_name: {}, ring_rays count: {}",
241 field_name,
242 ring_rays.get_size()));
243 }
244
245 shambase::Timer t;
246 t.start();
247
248 auto ret = RenderFieldGetter<Tvec, Tfield, SPHKernel>(context, solver_config, storage)
249 .runner_function(
250 field_name,
251 [&](auto field_getter) -> sham::DeviceBuffer<Tfield> {
252 return compute_azymuthal_integ(field_getter, ring_rays);
253 },
254 custom_getter);
255
256 t.stop();
257 if (shamcomm::world_rank() == 0) {
258 logger::info_ln(
259 "sph::CartesianRender",
260 sham::format("compute_azymuthal_integ took {}", t.get_time_str()));
261 }
262
263 return ret;
264 }
265
266 template<class Tvec, class Tfield, template<class> class SPHKernel>
267 auto CartesianRender<Tvec, Tfield, SPHKernel>::compute_slice(
268 std::function<field_getter_t> field_getter, const sham::DeviceBuffer<Tvec> &positions)
269 -> sham::DeviceBuffer<Tfield> {
270
271 auto part_counts = shamrock::solvergraph::Indexes<u32>::make_shared("part_counts", "N");
272 auto positions_refs
273 = std::make_shared<shamrock::solvergraph::FieldRefs<Tvec>>("positions", "\\mathbf{r}");
274 auto hpart_refs = std::make_shared<shamrock::solvergraph::FieldRefs<Tscal>>("h_part", "h");
275 auto field_data
276 = std::make_shared<shamrock::solvergraph::Field<Tfield>>(1, "field_data", "f");
277
278 shamrock::solvergraph::DDPatchDataFieldRef<Tvec> pos_dd;
279 shamrock::solvergraph::DDPatchDataFieldRef<Tscal> h_dd;
280
281 scheduler().for_each_patchdata_nonempty(
282 [&](const shamrock::patch::Patch cur_p, shamrock::patch::PatchDataLayer &pdat) {
283 u64 id = cur_p.id_patch;
284 u32 cnt = pdat.get_obj_cnt();
285
286 part_counts->indexes.add_obj(id, std::move(cnt));
287 pos_dd.add_obj(id, std::ref(pdat.get_field<Tvec>(0)));
288 h_dd.add_obj(
289 id, std::ref(pdat.get_field<Tscal>(pdat.pdl().get_field_idx<Tscal>("hpart"))));
290 });
291
292 positions_refs->set_refs(pos_dd);
293 hpart_refs->set_refs(h_dd);
294
295 field_data->ensure_sizes(part_counts->indexes);
296
297 scheduler().for_each_patchdata_nonempty(
298 [&](const shamrock::patch::Patch cur_p, shamrock::patch::PatchDataLayer &pdat) {
299 const sham::DeviceBuffer<Tfield> &src = field_getter(cur_p, pdat);
300 field_data->get(cur_p.id_patch).overwrite(src, static_cast<u32>(src.get_size()));
301 });
302
303 auto gpart_mass = shamrock::solvergraph::IDataEdge<Tscal>::make_shared("gpart_mass", "m");
304 gpart_mass->data = solver_config.gpart_mass;
305
306 auto tree_reduction_level
307 = shamrock::solvergraph::IDataEdge<u32>::make_shared("tree_reduction_level", "l");
308 tree_reduction_level->data = solver_config.tree_reduction_level;
309
310 auto interp_points = std::make_shared<shamrock::solvergraph::DeviceBufferEdge<Tvec>>(
311 "interp_points", "\\mathbf{q}");
312 interp_points->value.resize(positions.get_size());
313 interp_points->value.copy_from(positions);
314
315 auto interpolated_field = std::make_shared<shamrock::solvergraph::DeviceBufferEdge<Tfield>>(
316 "interpolated_field", "f_{\\rm interp}");
317
318 auto node = std::make_shared<SPHInterpolation<Tvec, Tfield, SPHKernel>>();
319 node->set_edges(
320 gpart_mass,
321 tree_reduction_level,
322 part_counts,
323 positions_refs,
324 hpart_refs,
325 field_data,
326 interp_points,
327 interpolated_field);
328 node->evaluate();
329
330 sham::DeviceBuffer<Tfield> ret{
331 interpolated_field->value.get_size(), shamsys::instance::get_compute_scheduler_ptr()};
332 ret.copy_from(interpolated_field->value);
333
334 return ret;
335 }
336
337 template<class Tvec, class Tfield, template<class> class SPHKernel>
338 auto CartesianRender<Tvec, Tfield, SPHKernel>::compute_column_integ(
339 std::function<field_getter_t> field_getter,
340 const sham::DeviceBuffer<shammath::Ray<Tvec>> &rays) -> sham::DeviceBuffer<Tfield> {
341
342 auto part_counts = shamrock::solvergraph::Indexes<u32>::make_shared("part_counts", "N");
343 auto positions_refs
344 = std::make_shared<shamrock::solvergraph::FieldRefs<Tvec>>("positions", "\\mathbf{r}");
345 auto hpart_refs = std::make_shared<shamrock::solvergraph::FieldRefs<Tscal>>("h_part", "h");
346 auto field_data
347 = std::make_shared<shamrock::solvergraph::Field<Tfield>>(1, "field_data", "f");
348
349 shamrock::solvergraph::DDPatchDataFieldRef<Tvec> pos_dd;
350 shamrock::solvergraph::DDPatchDataFieldRef<Tscal> h_dd;
351
352 scheduler().for_each_patchdata_nonempty(
353 [&](const shamrock::patch::Patch cur_p, shamrock::patch::PatchDataLayer &pdat) {
354 u64 id = cur_p.id_patch;
355 u32 cnt = pdat.get_obj_cnt();
356
357 part_counts->indexes.add_obj(id, std::move(cnt));
358 pos_dd.add_obj(id, std::ref(pdat.get_field<Tvec>(0)));
359 h_dd.add_obj(
360 id, std::ref(pdat.get_field<Tscal>(pdat.pdl().get_field_idx<Tscal>("hpart"))));
361 });
362
363 positions_refs->set_refs(pos_dd);
364 hpart_refs->set_refs(h_dd);
365
366 field_data->ensure_sizes(part_counts->indexes);
367
368 scheduler().for_each_patchdata_nonempty(
369 [&](const shamrock::patch::Patch cur_p, shamrock::patch::PatchDataLayer &pdat) {
370 const sham::DeviceBuffer<Tfield> &src = field_getter(cur_p, pdat);
371 field_data->get(cur_p.id_patch).overwrite(src, static_cast<u32>(src.get_size()));
372 });
373
374 auto gpart_mass = shamrock::solvergraph::IDataEdge<Tscal>::make_shared("gpart_mass", "m");
375 gpart_mass->data = solver_config.gpart_mass;
376
377 auto tree_reduction_level
378 = shamrock::solvergraph::IDataEdge<u32>::make_shared("tree_reduction_level", "l");
379 tree_reduction_level->data = solver_config.tree_reduction_level;
380
381 auto rays_edge
382 = std::make_shared<shamrock::solvergraph::DeviceBufferEdge<shammath::Ray<Tvec>>>(
383 "rays", "\\mathbf{r}_{\\rm ray}");
384 rays_edge->value.resize(rays.get_size());
385 rays_edge->value.copy_from(rays);
386
387 auto interpolated_field = std::make_shared<shamrock::solvergraph::DeviceBufferEdge<Tfield>>(
388 "interpolated_field", "f_{\\rm interp}");
389
390 auto node = std::make_shared<SPHColumnInteg<Tvec, Tfield, SPHKernel>>();
391 node->set_edges(
392 gpart_mass,
393 tree_reduction_level,
394 part_counts,
395 positions_refs,
396 hpart_refs,
397 field_data,
398 rays_edge,
399 interpolated_field);
400 node->evaluate();
401
402 sham::DeviceBuffer<Tfield> ret{
403 interpolated_field->value.get_size(), shamsys::instance::get_compute_scheduler_ptr()};
404 ret.copy_from(interpolated_field->value);
405
406 return ret;
407 }
408
409 template<class Tvec, class Tfield, template<class> class SPHKernel>
410 auto CartesianRender<Tvec, Tfield, SPHKernel>::compute_azymuthal_integ(
411 std::function<field_getter_t> field_getter,
412 const sham::DeviceBuffer<shammath::RingRay<Tvec>> &ring_rays)
413 -> sham::DeviceBuffer<Tfield> {
414
415 auto part_counts = shamrock::solvergraph::Indexes<u32>::make_shared("part_counts", "N");
416 auto positions_refs
417 = std::make_shared<shamrock::solvergraph::FieldRefs<Tvec>>("positions", "\\mathbf{r}");
418 auto hpart_refs = std::make_shared<shamrock::solvergraph::FieldRefs<Tscal>>("h_part", "h");
419 auto field_data
420 = std::make_shared<shamrock::solvergraph::Field<Tfield>>(1, "field_data", "f");
421
422 shamrock::solvergraph::DDPatchDataFieldRef<Tvec> pos_dd;
423 shamrock::solvergraph::DDPatchDataFieldRef<Tscal> h_dd;
424
425 scheduler().for_each_patchdata_nonempty(
426 [&](const shamrock::patch::Patch cur_p, shamrock::patch::PatchDataLayer &pdat) {
427 u64 id = cur_p.id_patch;
428 u32 cnt = pdat.get_obj_cnt();
429
430 part_counts->indexes.add_obj(id, std::move(cnt));
431 pos_dd.add_obj(id, std::ref(pdat.get_field<Tvec>(0)));
432 h_dd.add_obj(
433 id, std::ref(pdat.get_field<Tscal>(pdat.pdl().get_field_idx<Tscal>("hpart"))));
434 });
435
436 positions_refs->set_refs(pos_dd);
437 hpart_refs->set_refs(h_dd);
438
439 field_data->ensure_sizes(part_counts->indexes);
440
441 scheduler().for_each_patchdata_nonempty(
442 [&](const shamrock::patch::Patch cur_p, shamrock::patch::PatchDataLayer &pdat) {
443 const sham::DeviceBuffer<Tfield> &src = field_getter(cur_p, pdat);
444 field_data->get(cur_p.id_patch).overwrite(src, static_cast<u32>(src.get_size()));
445 });
446
447 auto gpart_mass = shamrock::solvergraph::IDataEdge<Tscal>::make_shared("gpart_mass", "m");
448 gpart_mass->data = solver_config.gpart_mass;
449
450 auto tree_reduction_level
451 = shamrock::solvergraph::IDataEdge<u32>::make_shared("tree_reduction_level", "l");
452 tree_reduction_level->data = solver_config.tree_reduction_level;
453
454 auto ring_rays_edge
455 = std::make_shared<shamrock::solvergraph::DeviceBufferEdge<shammath::RingRay<Tvec>>>(
456 "ring_rays", "\\mathbf{r}_{\\rm ring}");
457 ring_rays_edge->value.resize(ring_rays.get_size());
458 ring_rays_edge->value.copy_from(ring_rays);
459
460 auto interpolated_field = std::make_shared<shamrock::solvergraph::DeviceBufferEdge<Tfield>>(
461 "interpolated_field", "f_{\\rm interp}");
462
463 auto node = std::make_shared<SPHAzymuthalInteg<Tvec, Tfield, SPHKernel>>();
464 node->set_edges(
465 gpart_mass,
466 tree_reduction_level,
467 part_counts,
468 positions_refs,
469 hpart_refs,
470 field_data,
471 ring_rays_edge,
472 interpolated_field);
473 node->evaluate();
474
475 sham::DeviceBuffer<Tfield> ret{
476 interpolated_field->value.get_size(), shamsys::instance::get_compute_scheduler_ptr()};
477 ret.copy_from(interpolated_field->value);
478
479 return ret;
480 }
481
482 template<class Tvec, class Tfield, template<class> class SPHKernel>
483 auto CartesianRender<Tvec, Tfield, SPHKernel>::compute_azymuthal_integ(
484 shamrock::solvergraph::Field<Tfield> &field,
485 const sham::DeviceBuffer<shammath::RingRay<Tvec>> &ring_rays)
486 -> sham::DeviceBuffer<Tfield> {
487
488 if (field.get_nvar() != 1) {
489 throw shambase::make_except_with_loc<std::invalid_argument>(
490 "render only supports fields with nvar == 1");
491 }
492
493 shambase::DistributedData<u32> sizes{};
494 scheduler().for_each_patchdata_nonempty(
495 [&](const shamrock::patch::Patch p, shamrock::patch::PatchDataLayer &pdat) {
496 sizes.add_obj(p.id_patch, pdat.get_obj_cnt());
497 });
498 field.check_sizes(sizes);
499
500 auto field_getter
501 = [&](const shamrock::patch::Patch cur_p,
502 shamrock::patch::PatchDataLayer &pdat) -> const sham::DeviceBuffer<Tfield> & {
503 return field.get_buf(cur_p.id_patch);
504 };
505
506 return compute_azymuthal_integ(field_getter, ring_rays);
507 }
508
509 template<class Tvec, class Tfield, template<class> class SPHKernel>
510 auto CartesianRender<Tvec, Tfield, SPHKernel>::compute_slice(
511 std::function<field_getter_t> field_getter,
512 Tvec center,
513 Tvec delta_x,
514 Tvec delta_y,
515 u32 nx,
516 u32 ny) -> sham::DeviceBuffer<Tfield> {
517
518 auto positions = pixel_to_positions(center, delta_x, delta_y, nx, ny);
519
520 return compute_slice(field_getter, positions);
521 }
522
523 template<class Tvec, class Tfield, template<class> class SPHKernel>
524 auto CartesianRender<Tvec, Tfield, SPHKernel>::compute_column_integ(
525 std::function<field_getter_t> field_getter,
526 Tvec center,
527 Tvec delta_x,
528 Tvec delta_y,
529 u32 nx,
530 u32 ny) -> sham::DeviceBuffer<Tfield> {
531
532 auto rays = pixel_to_orthographic_rays(center, delta_x, delta_y, nx, ny);
533
534 return compute_column_integ(field_getter, rays);
535 }
536
537 template<class Tvec, class Tfield, template<class> class SPHKernel>
538 auto CartesianRender<Tvec, Tfield, SPHKernel>::compute_slice(
539 shamrock::solvergraph::Field<Tfield> &field,
540 Tvec center,
541 Tvec delta_x,
542 Tvec delta_y,
543 u32 nx,
544 u32 ny) -> sham::DeviceBuffer<Tfield> {
545
546 auto positions = pixel_to_positions(center, delta_x, delta_y, nx, ny);
547
548 return compute_slice(field, positions);
549 }
550
551 template<class Tvec, class Tfield, template<class> class SPHKernel>
552 auto CartesianRender<Tvec, Tfield, SPHKernel>::compute_column_integ(
553 shamrock::solvergraph::Field<Tfield> &field,
554 Tvec center,
555 Tvec delta_x,
556 Tvec delta_y,
557 u32 nx,
558 u32 ny) -> sham::DeviceBuffer<Tfield> {
559
560 auto rays = pixel_to_orthographic_rays(center, delta_x, delta_y, nx, ny);
561
562 return compute_column_integ(field, rays);
563 }
564
565 template<class Tvec, class Tfield, template<class> class SPHKernel>
566 auto CartesianRender<Tvec, Tfield, SPHKernel>::compute_slice(
567 std::string field_name,
568 Tvec center,
569 Tvec delta_x,
570 Tvec delta_y,
571 u32 nx,
572 u32 ny,
573 std::optional<
574 std::function<pybind11::array_t<Tfield>(size_t, shamrock::PatchDataLazyGetter &)>>
575 custom_getter) -> sham::DeviceBuffer<Tfield> {
576 auto positions = pixel_to_positions(center, delta_x, delta_y, nx, ny);
577 return compute_slice(std::move(field_name), positions, std::move(custom_getter));
578 }
579
580 template<class Tvec, class Tfield, template<class> class SPHKernel>
581 auto CartesianRender<Tvec, Tfield, SPHKernel>::compute_column_integ(
582 std::string field_name,
583 Tvec center,
584 Tvec delta_x,
585 Tvec delta_y,
586 u32 nx,
587 u32 ny,
588 std::optional<
589 std::function<pybind11::array_t<Tfield>(size_t, shamrock::PatchDataLazyGetter &)>>
590 custom_getter) -> sham::DeviceBuffer<Tfield> {
591 auto rays = pixel_to_orthographic_rays(center, delta_x, delta_y, nx, ny);
592 return compute_column_integ(std::move(field_name), rays, std::move(custom_getter));
593 }
594
595} // namespace shammodels::sph::modules
596
597using namespace shammath;
598template class shammodels::sph::modules::CartesianRender<f64_3, f64, M4>;
599template class shammodels::sph::modules::CartesianRender<f64_3, f64, M6>;
600template class shammodels::sph::modules::CartesianRender<f64_3, f64, M8>;
601
602template class shammodels::sph::modules::CartesianRender<f64_3, f64, C2>;
603template class shammodels::sph::modules::CartesianRender<f64_3, f64, C4>;
604template class shammodels::sph::modules::CartesianRender<f64_3, f64, C6>;
605
606template class shammodels::sph::modules::CartesianRender<f64_3, f64_3, M4>;
607template class shammodels::sph::modules::CartesianRender<f64_3, f64_3, M6>;
608template class shammodels::sph::modules::CartesianRender<f64_3, f64_3, M8>;
609
610template class shammodels::sph::modules::CartesianRender<f64_3, f64_3, C2>;
611template class shammodels::sph::modules::CartesianRender<f64_3, f64_3, C4>;
612template class shammodels::sph::modules::CartesianRender<f64_3, f64_3, C6>;
DeviceBufferEdge.hpp
Solver graph edge wrapping a global device buffer.
shammodels::gsph::edges::sizes
constexpr const char * sizes
Temporary sizes for h-iteration.
Definition FieldNames.hpp:113
shammodels::gsph::edges::part_counts
constexpr const char * part_counts
Particle counts per patch.
Definition FieldNames.hpp:101
SPHAzymuthalInteg.hpp
SPH azimuthal integration solver graph node.
SPHColumnInteg.hpp
SPH column integration solver graph node.
SPHInterpolation.hpp
SPH slice interpolation solver graph node.
f64
double f64
Alias for double.
Definition aliases_float.hpp:20
u32
std::uint32_t u32
32 bit unsigned integer
Definition aliases_int.hpp:27
u64
std::uint64_t u64
64 bit unsigned integer
Definition aliases_int.hpp:26
sham::DeviceBuffer::copy_from
void copy_from(const DeviceBuffer< T, new_target > &other, size_t copy_size)
Copies the content of another buffer to this one.
Definition DeviceBuffer.hpp:859
sham::DeviceBuffer::get_size
size_t get_size() const
Gets the number of elements in the buffer.
Definition DeviceBuffer.hpp:476
sham::DeviceScheduler::get_queue
DeviceQueue & get_queue(u32 id=0)
Get a reference to a DeviceQueue.
Definition DeviceScheduler.cpp:57
shambase::DistributedData::add_obj
iterator add_obj(u64 id, T &&obj)
Adds a new object to the collection.
Definition DistributedData.hpp:67
shambase::Timer::get_time_str
std::string get_time_str() const
Converts the stored nanosecond time to a string representation.
Definition Timer.hpp:79
shambase::Timer::start
void start()
Starts the timer.
Definition Timer.hpp:51
shambase::Timer::stop
void stop()
Stops the timer and stores the elapsed time in nanoseconds.
Definition Timer.hpp:65
shamrock::patch::PatchDataLayerLayout::get_field_idx
u32 get_field_idx(const std::string &field_name) const
Get the field id if matching name & type.
Definition PatchDataLayerLayout.cpp:130
shamrock::patch::PatchDataLayer::get_obj_cnt
u32 get_obj_cnt() const
get the number of objects (particles) stored in this layer
Definition PatchDataLayer.cpp:346
exception.hpp
This header file contains utility functions related to exception handling in the code.
kernel_call.hpp
sham::kernel_call
void kernel_call(sham::DeviceQueue &q, RefIn in, RefOut in_out, u32 n, Functor &&func, SourceLocation &&callsite=SourceLocation{})
Submit a kernel to a SYCL queue.
Definition kernel_call.hpp:344
shambase::make_except_with_loc
ExcptTypes make_except_with_loc(std::string message, SourceLocation loc=SourceLocation{})
Create an exception with a message and a location.
Definition exception.hpp:105
shamcomm::world_rank
i32 world_rank()
Gives the rank of the current process in the MPI communicator.
Definition worldInfo.cpp:41
shammath
namespace for math utility
Definition AABB.hpp:26
shammodels::sph::modules
namespace for the sph model modules
Definition AnalysisAngularMomentum.hpp:28
shamrock::patch::Patch::id_patch
u64 id_patch
unique key that identify the patch
Definition Patch.hpp:86
Generated on for Shamrock by doxygen 1.15.0