Shamrock 2025.10.0
Astrophysical Code
Loading...
Searching...
No Matches
ExternalForces.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/memory.hpp"
21#include "shamcomm/logs.hpp"
37
38namespace shambase {
39
40 template<class T>
41 std::shared_ptr<T> to_shared(T &&t) {
42 return std::make_shared<T>(std::forward<T>(t));
43 }
44} // namespace shambase
45
46template<class Tvec, template<class> class SPHKernel>
48
49 StackEntry stack_loc{};
50
51 sham::DeviceQueue &q = shamsys::instance::get_compute_scheduler().get_queue();
52
53 Tscal gpart_mass = solver_config.gpart_mass;
54
55 using namespace shamrock;
56 using namespace shamrock::patch;
57
58 PatchDataLayerLayout &pdl = scheduler().pdl_old();
59
60 const u32 iaxyz_ext = pdl.get_field_idx<Tvec>("axyz_ext");
61 modules::SinkParticlesUpdate<Tvec, SPHKernel> sink_update(context, solver_config, storage);
62
63 scheduler().for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
64 PatchDataField<Tvec> &field = pdat.get_field<Tvec>(iaxyz_ext);
65 field.field_raz();
66 });
67
68 sink_update.compute_sph_forces();
69
70 if (solver_config.ext_force_config.ext_forces.empty()) {
71 return;
72 }
73
74 auto field_xyz = shamrock::solvergraph::FieldRefs<Tvec>::make_shared("", "");
75
77 [&](shamrock::solvergraph::FieldRefs<Tvec> &field_xyz_edge) {
79 scheduler().for_each_patchdata_nonempty([&](const Patch p, PatchDataLayer &pdat) {
80 auto &field = pdat.get_field<Tvec>(0);
81 field_xyz_refs.add_obj(p.id_patch, std::ref(field));
82 });
83 field_xyz_edge.set_refs(field_xyz_refs);
84 });
85 set_field_xyz.set_edges(field_xyz);
86 set_field_xyz.evaluate();
87
88 auto field_axyz_ext = shamrock::solvergraph::FieldRefs<Tvec>::make_shared("", "");
89
91 [&](shamrock::solvergraph::FieldRefs<Tvec> &field_axyz_ext_edge) {
93 scheduler().for_each_patchdata_nonempty([&](const Patch p, PatchDataLayer &pdat) {
94 auto &field = pdat.get_field<Tvec>(iaxyz_ext);
95 field_axyz_ext_refs.add_obj(p.id_patch, std::ref(field));
96 });
97 field_axyz_ext_edge.set_refs(field_axyz_ext_refs);
98 });
99 set_field_axyz_ext.set_edges(field_axyz_ext);
100 set_field_axyz_ext.evaluate();
101
102 auto sizes = shamrock::solvergraph::Indexes<u32>::make_shared("", "");
103
106 sizes.indexes = {};
107 scheduler().for_each_patchdata_nonempty([&](const Patch p, PatchDataLayer &pdat) {
108 sizes.indexes.add_obj(p.id_patch, pdat.get_obj_cnt());
109 });
110 });
111 set_sizes.set_edges(sizes);
112 set_sizes.evaluate();
113
114 auto constant_G = shamrock::solvergraph::IDataEdge<Tscal>::make_shared("", "");
115 auto constant_c = shamrock::solvergraph::IDataEdge<Tscal>::make_shared("", "");
116
119 constant_G.data = solver_config.get_constant_G();
120 });
121
124 constant_c.data = solver_config.get_constant_c();
125 });
126
127 set_constant_G.set_edges(constant_G);
128 set_constant_c.set_edges(constant_c);
129
130 std::vector<std::shared_ptr<shamrock::solvergraph::INode>> add_ext_forces_seq{};
131 add_ext_forces_seq.push_back(shambase::to_shared(std::move(set_constant_G)));
132 add_ext_forces_seq.push_back(shambase::to_shared(std::move(set_constant_c)));
133
134 for (auto var_force : solver_config.ext_force_config.ext_forces) {
135 if (EF_PointMass *ext_force = std::get_if<EF_PointMass>(&var_force.val)) {
136
137 auto central_mass = shamrock::solvergraph::IDataEdge<Tscal>::make_shared("", "");
138 auto central_pos = shamrock::solvergraph::IDataEdge<Tvec>::make_shared("", "");
139
141 set_central_mass([cmass = ext_force->central_mass](
143 central_mass.data = cmass;
144 });
145 set_central_mass.set_edges(central_mass);
146
148 set_central_pos([cpos = ext_force->central_pos](
150 central_pos.data = cpos;
151 });
152 set_central_pos.set_edges(central_pos);
153
154 common::modules::AddForceCentralGravPotential<Tvec> add_force_central_grav_potential;
155 add_force_central_grav_potential.set_edges(
156 constant_G, central_mass, central_pos, field_xyz, sizes, field_axyz_ext);
157
158 add_ext_forces_seq.push_back(
159 std::make_shared<shamrock::solvergraph::OperationSequence>(
160 "Point mass",
161 std::vector<std::shared_ptr<shamrock::solvergraph::INode>>{
162 shambase::to_shared(std::move(set_central_pos)),
163 shambase::to_shared(std::move(set_central_mass)),
164 shambase::to_shared(std::move(add_force_central_grav_potential))}));
165
166 } else if (EF_PN_PW *ext_force = std::get_if<EF_PN_PW>(&var_force.val)) {
167
168 auto central_mass = shamrock::solvergraph::IDataEdge<Tscal>::make_shared("", "");
169 auto central_pos = shamrock::solvergraph::IDataEdge<Tvec>::make_shared("", "");
170
172 set_central_mass([cmass = ext_force->central_mass](
174 central_mass.data = cmass;
175 });
176 set_central_mass.set_edges(central_mass);
177
179 set_central_pos([cpos = ext_force->central_pos](
181 central_pos.data = cpos;
182 });
183 set_central_pos.set_edges(central_pos);
184
185 common::modules::AddForcePaczynskiWiita<Tvec> add_force_paczynski_wiita;
186 add_force_paczynski_wiita.set_edges(
187 constant_G,
188 constant_c,
189 central_mass,
190 central_pos,
191 field_xyz,
192 sizes,
193 field_axyz_ext);
194
195 add_ext_forces_seq.push_back(
196 std::make_shared<shamrock::solvergraph::OperationSequence>(
197 "Pseudo-Newtonian PW",
198 std::vector<std::shared_ptr<shamrock::solvergraph::INode>>{
199 shambase::to_shared(std::move(set_central_pos)),
200 shambase::to_shared(std::move(set_central_mass)),
201 shambase::to_shared(std::move(add_force_paczynski_wiita))}));
202
203 } else if (EF_LenseThirring *ext_force = std::get_if<EF_LenseThirring>(&var_force.val)) {
204
205 auto central_mass = shamrock::solvergraph::IDataEdge<Tscal>::make_shared("", "");
206 auto central_pos = shamrock::solvergraph::IDataEdge<Tvec>::make_shared("", "");
207 auto central_vel = shamrock::solvergraph::IDataEdge<Tvec>::make_shared("", "");
208
210 set_central_mass([cmass = ext_force->central_mass](
212 central_mass.data = cmass;
213 });
214 set_central_mass.set_edges(central_mass);
215
217 set_central_pos([cpos = ext_force->central_pos](
219 central_pos.data = cpos;
220 });
221 set_central_pos.set_edges(central_pos);
222
224 set_central_vel([cvel = ext_force->central_vel](
226 central_vel.data = cvel;
227 });
228 set_central_vel.set_edges(central_vel);
229
230 common::modules::AddForceCentralGravPotential<Tvec> add_force_central_grav_potential;
231 add_force_central_grav_potential.set_edges(
232 constant_G, central_mass, central_pos, field_xyz, sizes, field_axyz_ext);
233
234 add_ext_forces_seq.push_back(
235 std::make_shared<shamrock::solvergraph::OperationSequence>(
236 "Point mass",
237 std::vector<std::shared_ptr<shamrock::solvergraph::INode>>{
238 shambase::to_shared(std::move(set_central_pos)),
239 shambase::to_shared(std::move(set_central_mass)),
240 shambase::to_shared(std::move(add_force_central_grav_potential))}));
241
242 } else if (
243 EF_ShearingBoxForce *ext_force = std::get_if<EF_ShearingBoxForce>(&var_force.val)) {
244
245 auto eta = shamrock::solvergraph::IDataEdge<Tscal>::make_shared("", "");
248 eta.data = ext_force->eta;
249 });
250 set_eta.set_edges(eta);
251
253 add_force_shearing_box_inertial_part{};
254 add_force_shearing_box_inertial_part.set_edges(eta, field_xyz, sizes, field_axyz_ext);
255
256 add_ext_forces_seq.push_back(
257 std::make_shared<shamrock::solvergraph::OperationSequence>(
258 "Shearing box force",
259 std::vector<std::shared_ptr<shamrock::solvergraph::INode>>{
260 shambase::to_shared(std::move(set_eta)),
261 shambase::to_shared(std::move(add_force_shearing_box_inertial_part))}));
262
263 } else if (
264 EF_VerticalDiscPotential *ext_force
265 = std::get_if<EF_VerticalDiscPotential>(&var_force.val)) {
266
267 auto central_mass = shamrock::solvergraph::IDataEdge<Tscal>::make_shared("", "");
268 auto R0 = shamrock::solvergraph::IDataEdge<Tscal>::make_shared("", "");
269
271 set_central_mass([cmass = ext_force->central_mass](
273 central_mass.data = cmass;
274 });
275 set_central_mass.set_edges(central_mass);
276
278 [r = ext_force->R0](shamrock::solvergraph::IDataEdge<Tscal> &R0) {
279 R0.data = r; // no support for offset yet
280 });
281 set_R0.set_edges(R0);
282
283 common::modules::AddForceVerticalDiscPotential<Tvec> add_force_vertical_disc_potential;
284 add_force_vertical_disc_potential.set_edges(
285 constant_G, central_mass, R0, field_xyz, sizes, field_axyz_ext);
286
287 add_ext_forces_seq.push_back(
288 std::make_shared<shamrock::solvergraph::OperationSequence>(
289 "Vertical disc potential",
290 std::vector<std::shared_ptr<shamrock::solvergraph::INode>>{
291 shambase::to_shared(std::move(set_R0)),
292 shambase::to_shared(std::move(set_central_mass)),
293 shambase::to_shared(std::move(add_force_vertical_disc_potential))}));
294
295 } else if (
296 EF_VelocityDissipation *ext_force
297 = std::get_if<EF_VelocityDissipation>(&var_force.val)) {
298
299 } else {
300 shambase::throw_unimplemented("this force is not handled, yet ...");
301 }
302 }
303
304 if (add_ext_forces_seq.size() > 0) {
306 "Add external forces", std::move(add_ext_forces_seq));
307 seq.evaluate();
308 }
309}
310
311template<class T>
312std::shared_ptr<shamrock::solvergraph::INode> register_constant_set(
313 shamrock::solvergraph::SolverGraph &solver_graph, std::string name, std::function<T()> getter) {
314 solver_graph.register_edge(name, shamrock::solvergraph::IDataEdge<T>("", ""));
315
316 solver_graph.register_node(
317 "set_" + name,
320 edge.data = getter();
321 }));
322
323 solver_graph
325 "set_" + name)
326 .set_edges(solver_graph.get_edge_ptr_base(name));
327
328 return solver_graph.get_node_ptr_base("set_" + name);
329}
330
331template<class Tvec, template<class> class SPHKernel>
333
334 StackEntry stack_loc{};
335
336 sham::DeviceQueue &q = shamsys::instance::get_compute_scheduler().get_queue();
337
338 Tscal gpart_mass = solver_config.gpart_mass;
339
340 using namespace shamrock;
341 using namespace shamrock::patch;
342
343 PatchDataLayerLayout &pdl = scheduler().pdl_old();
344
345 const u32 iaxyz = pdl.get_field_idx<Tvec>("axyz");
346 const u32 ivxyz = pdl.get_field_idx<Tvec>("vxyz");
347 const u32 iaxyz_ext = pdl.get_field_idx<Tvec>("axyz_ext");
348
349 scheduler().for_each_patchdata_nonempty([&](Patch cur_p, PatchDataLayer &pdat) {
350 sham::DeviceBuffer<Tvec> &buf_axyz = pdat.get_field_buf_ref<Tvec>(iaxyz);
351 sham::DeviceBuffer<Tvec> &buf_axyz_ext = pdat.get_field_buf_ref<Tvec>(iaxyz_ext);
352
354 q,
355 sham::MultiRef{buf_axyz_ext},
356 sham::MultiRef{buf_axyz},
357 pdat.get_obj_cnt(),
358 [](u32 gid, const Tvec *__restrict axyz_ext, Tvec *__restrict axyz) {
359 axyz[gid] += axyz_ext[gid];
360 });
361 });
362
363 if (solver_config.ext_force_config.ext_forces.empty()) {
364 return; // skip if no external forces
365 }
366
367 using SolverConfigExtForce = typename Config::ExtForceConfig;
368 using EF_PointMass = typename SolverConfigExtForce::PointMass;
369 using EF_PN_PW = typename SolverConfigExtForce::PN_PW;
370 using EF_LenseThirring = typename SolverConfigExtForce::LenseThirring;
371
372 using namespace shamrock::solvergraph;
373 SolverGraph solver_graph{};
374
375 auto set_constant_G = register_constant_set<Tscal>(solver_graph, "constant_G", [&]() {
376 return solver_config.get_constant_G();
377 });
378 auto set_constant_c = register_constant_set<Tscal>(solver_graph, "constant_c", [&]() {
379 return solver_config.get_constant_c();
380 });
381
382 bool is_G_needed = false;
383 bool is_c_needed = false;
384
385 for (auto var_force : solver_config.ext_force_config.ext_forces) {
386 if (EF_PointMass *ext_force = std::get_if<EF_PointMass>(&var_force.val)) {
387
388 } else if (EF_PN_PW *ext_force = std::get_if<EF_PN_PW>(&var_force.val)) {
389 is_G_needed = true;
390 is_c_needed = true;
391 } else if (EF_LenseThirring *ext_force = std::get_if<EF_LenseThirring>(&var_force.val)) {
392 is_G_needed = true;
393 is_c_needed = true;
394 } else if (
395 EF_ShearingBoxForce *ext_force = std::get_if<EF_ShearingBoxForce>(&var_force.val)) {
396 } else if (
397 EF_VerticalDiscPotential *ext_force
398 = std::get_if<EF_VerticalDiscPotential>(&var_force.val)) {
399 } else if (
400 EF_VelocityDissipation *ext_force
401 = std::get_if<EF_VelocityDissipation>(&var_force.val)) {
402 } else {
403 shambase::throw_unimplemented("this force is not handled, yet ...");
404 }
405 }
406
407 std::vector<std::shared_ptr<shamrock::solvergraph::INode>> add_ext_forces_seq{};
408
409 if (is_G_needed) {
410 add_ext_forces_seq.push_back(set_constant_G);
411 }
412 if (is_c_needed) {
413 add_ext_forces_seq.push_back(set_constant_c);
414 }
415
416 auto field_xyz = solver_graph.register_edge("field_xyz", FieldRefs<Tvec>("", ""));
417 auto field_vxyz = solver_graph.register_edge("field_vxyz", FieldRefs<Tvec>("", ""));
418 auto field_axyz = solver_graph.register_edge("field_axyz", FieldRefs<Tvec>("", ""));
419 auto field_sizes = solver_graph.register_edge("field_sizes", Indexes<u32>("", ""));
420
421 auto set_field_xyz = solver_graph.register_node(
422 "set_field_xyz", NodeSetEdge<FieldRefs<Tvec>>([&](FieldRefs<Tvec> &field_xyz_edge) {
423 DDPatchDataFieldRef<Tvec> field_xyz_refs = {};
424 scheduler().for_each_patchdata_nonempty([&](const Patch p, PatchDataLayer &pdat) {
425 auto &field = pdat.get_field<Tvec>(0);
426 field_xyz_refs.add_obj(p.id_patch, std::ref(field));
427 });
428 field_xyz_edge.set_refs(field_xyz_refs);
429 }));
430 shambase::get_check_ref(set_field_xyz).set_edges(field_xyz);
431
432 auto set_field_vxyz = solver_graph.register_node(
433 "set_field_vxyz", NodeSetEdge<FieldRefs<Tvec>>([&](FieldRefs<Tvec> &field_vxyz_edge) {
434 DDPatchDataFieldRef<Tvec> field_vxyz_refs = {};
435 scheduler().for_each_patchdata_nonempty([&](const Patch p, PatchDataLayer &pdat) {
436 auto &field = pdat.get_field<Tvec>(ivxyz);
437 field_vxyz_refs.add_obj(p.id_patch, std::ref(field));
438 });
439 field_vxyz_edge.set_refs(field_vxyz_refs);
440 }));
441 shambase::get_check_ref(set_field_vxyz).set_edges(field_vxyz);
442
443 auto set_field_axyz = solver_graph.register_node(
444 "set_field_axyz", NodeSetEdge<FieldRefs<Tvec>>([&](FieldRefs<Tvec> &field_axyz_edge) {
445 DDPatchDataFieldRef<Tvec> field_axyz_refs = {};
446 scheduler().for_each_patchdata_nonempty([&](const Patch p, PatchDataLayer &pdat) {
447 auto &field = pdat.get_field<Tvec>(iaxyz);
448 field_axyz_refs.add_obj(p.id_patch, std::ref(field));
449 });
450 field_axyz_edge.set_refs(field_axyz_refs);
451 }));
452 shambase::get_check_ref(set_field_axyz).set_edges(field_axyz);
453
454 auto set_field_sizes = solver_graph.register_node(
455 "set_field_sizes", NodeSetEdge<Indexes<u32>>([&](Indexes<u32> &sizes) {
456 sizes.indexes = {};
457 scheduler().for_each_patchdata_nonempty([&](const Patch p, PatchDataLayer &pdat) {
458 sizes.indexes.add_obj(p.id_patch, pdat.get_obj_cnt());
459 });
460 }));
461 shambase::get_check_ref(set_field_sizes).set_edges(field_sizes);
462
463 add_ext_forces_seq.push_back(set_field_xyz);
464 add_ext_forces_seq.push_back(set_field_vxyz);
465 add_ext_forces_seq.push_back(set_field_axyz);
466 add_ext_forces_seq.push_back(set_field_sizes);
467
468 for (u32 i = 0; i < solver_config.ext_force_config.ext_forces.size(); i++) {
469
470 auto &var_force = solver_config.ext_force_config.ext_forces[i];
471
472 std::string prefix = sham::format("ext_force_{}_", i);
473
474 if (EF_PointMass *ext_force = std::get_if<EF_PointMass>(&var_force.val)) {
475
476 } else if (EF_PN_PW *ext_force = std::get_if<EF_PN_PW>(&var_force.val)) {
477
478 } else if (EF_LenseThirring *ext_force = std::get_if<EF_LenseThirring>(&var_force.val)) {
479
480 std::string prefix_cmass = prefix + "cmass_";
481 std::string prefix_central_pos = prefix + "central_pos_";
482 std::string prefix_central_vel = prefix + "central_vel_";
483 std::string prefix_a_spin = prefix + "a_spin_";
484 std::string prefix_dir_spin = prefix + "dir_spin_";
485 std::string prefix_lt = prefix + "lt_";
486
487 auto set_cmass = register_constant_set<Tscal>(solver_graph, prefix_cmass, [&]() {
488 return ext_force->central_mass;
489 });
490
491 auto set_central_pos
492 = register_constant_set<Tvec>(solver_graph, prefix_central_pos, [&]() {
493 return ext_force->central_pos;
494 });
495
496 auto set_central_vel
497 = register_constant_set<Tvec>(solver_graph, prefix_central_vel, [&]() {
498 return ext_force->central_vel;
499 });
500
501 auto set_a_spin = register_constant_set<Tscal>(solver_graph, prefix_a_spin, [&]() {
502 return ext_force->a_spin;
503 });
504
505 auto set_dir_spin = register_constant_set<Tvec>(solver_graph, prefix_dir_spin, [&]() {
506 return ext_force->dir_spin;
507 });
508
509 auto add_force_lense_thirring = solver_graph.register_node(
511 shambase::get_check_ref(add_force_lense_thirring)
512 .set_edges(
513 solver_graph.get_edge_ptr<IDataEdge<Tscal>>("constant_G"),
514 solver_graph.get_edge_ptr<IDataEdge<Tscal>>("constant_c"),
515 solver_graph.get_edge_ptr<IDataEdge<Tscal>>(prefix_cmass),
516 solver_graph.get_edge_ptr<IDataEdge<Tvec>>(prefix_central_pos),
517 solver_graph.get_edge_ptr<IDataEdge<Tvec>>(prefix_central_vel),
518 solver_graph.get_edge_ptr<IDataEdge<Tscal>>(prefix_a_spin),
519 solver_graph.get_edge_ptr<IDataEdge<Tvec>>(prefix_dir_spin),
520 solver_graph.get_edge_ptr<IFieldSpan<Tvec>>("field_xyz"),
521 solver_graph.get_edge_ptr<IFieldSpan<Tvec>>("field_vxyz"),
522 solver_graph.get_edge_ptr<Indexes<u32>>("field_sizes"),
523 solver_graph.get_edge_ptr<IFieldSpan<Tvec>>("field_axyz"));
524
525 add_ext_forces_seq.push_back(set_cmass);
526 add_ext_forces_seq.push_back(set_central_pos);
527 add_ext_forces_seq.push_back(set_a_spin);
528 add_ext_forces_seq.push_back(set_dir_spin);
529 // set_central_vel is intentionally not run: the external force's central object is
530 // stationary, so central_vel stays null.
531 add_ext_forces_seq.push_back(solver_graph.get_node_ptr_base(prefix_lt));
532
533 } else if (
534 EF_ShearingBoxForce *ext_force = std::get_if<EF_ShearingBoxForce>(&var_force.val)) {
535
536 std::string prefix_Omega_0 = prefix + "Omega_0_";
537 std::string prefix_q = prefix + "q_";
538 std::string prefix_shearing_box = prefix + "shearing_box_";
539
540 auto set_Omega_0 = register_constant_set<Tscal>(solver_graph, prefix_Omega_0, [&]() {
541 return ext_force->Omega_0;
542 });
543
544 auto set_q = register_constant_set<Tscal>(solver_graph, prefix_q, [&]() {
545 return ext_force->q;
546 });
547
548 auto add_force_shearing_box_non_inertial = solver_graph.register_node(
549 prefix_shearing_box,
551 shambase::get_check_ref(add_force_shearing_box_non_inertial)
552 .set_edges(
553 solver_graph.get_edge_ptr<IDataEdge<Tscal>>(prefix_Omega_0),
554 solver_graph.get_edge_ptr<IDataEdge<Tscal>>(prefix_q),
555 solver_graph.get_edge_ptr<IFieldSpan<Tvec>>("field_xyz"),
556 solver_graph.get_edge_ptr<IFieldSpan<Tvec>>("field_vxyz"),
557 solver_graph.get_edge_ptr<Indexes<u32>>("field_sizes"),
558 solver_graph.get_edge_ptr<IFieldSpan<Tvec>>("field_axyz"));
559
560 add_ext_forces_seq.push_back(set_Omega_0);
561 add_ext_forces_seq.push_back(set_q);
562 add_ext_forces_seq.push_back(solver_graph.get_node_ptr_base(prefix_shearing_box));
563
564 } else if (
565 EF_VerticalDiscPotential *ext_force
566 = std::get_if<EF_VerticalDiscPotential>(&var_force.val)) {
567 } else if (
568 EF_VelocityDissipation *ext_force
569 = std::get_if<EF_VelocityDissipation>(&var_force.val)) {
570 std::string prefix_eta = prefix + "eta_";
571 std::string prefix_velocity_dissipation = prefix + "velocity_dissipation_";
572
573 auto set_eta
574 = register_constant_set<Tscal>(solver_graph, prefix_eta, [eta = ext_force->eta]() {
575 return eta;
576 });
577
578 auto add_force_velocity_dissipation = solver_graph.register_node(
579 prefix_velocity_dissipation,
581 shambase::get_check_ref(add_force_velocity_dissipation)
582 .set_edges(
583 solver_graph.get_edge_ptr<IDataEdge<Tscal>>(prefix_eta),
584 solver_graph.get_edge_ptr<IFieldSpan<Tvec>>("field_vxyz"),
585 solver_graph.get_edge_ptr<Indexes<u32>>("field_sizes"),
586 solver_graph.get_edge_ptr<IFieldSpan<Tvec>>("field_axyz"));
587
588 add_ext_forces_seq.push_back(set_eta);
589 add_ext_forces_seq.push_back(
590 solver_graph.get_node_ptr_base(prefix_velocity_dissipation));
591
592 } else {
593 shambase::throw_unimplemented("this force is not handled, yet ...");
594 }
595 }
596
597 if (add_ext_forces_seq.size() > 0) {
598 OperationSequence seq("Add external forces", std::move(add_ext_forces_seq));
599 seq.evaluate();
600 }
601}
602
603using namespace shammath;
607
Adds the acceleration from a central gravitational potential (point mass).
Adds the Lense-Thirring force acceleration.
Adds the acceleration from a Paczynski Wiita (1980) pseudo-newtonian potential.
Adds the inertial part of the acceleration for a shearing box force.
Adds the non-inertial part of the acceleration for a shearing box force.
Adds the acceleration from a velocity dissipation force.
Adds the thin disc vertical acceleration of a central mass at cylindrical radius R0,...
shambase::DistributedData< PatchDataFieldRef< T > > DDPatchDataFieldRef
Alias for a DistributedData of PatchDataFieldRefs.
Node that applies a custom function to modify connected edges.
Declare a class to register and retrieve nodes and edges from a unique container.
std::uint32_t u32
32 bit unsigned integer
A buffer allocated in USM (Unified Shared Memory).
A SYCL queue associated with a device and a context.
iterator add_obj(u64 id, T &&obj)
Adds a new object to the collection.
void add_ext_forces()
add external forces to the particle acceleration, note that forces dependant on velocity shlould be a...
void compute_ext_forces_indep_v()
is ran once per timestep, it computes the forces that are independant of velocity
u32 get_field_idx(const std::string &field_name) const
Get the field id if matching name & type.
PatchDataLayer container class, the layout is described in patchdata_layout.
u32 get_obj_cnt() const
get the number of objects (particles) stored in this layer
Interface for a solver graph edge representing a field as spans.
void evaluate()
Evaluate the node.
Definition INode.hpp:156
A node that applies a custom function to modify connected edges.
void set_edges(std::shared_ptr< IEdge > to_set)
Set the edges of the node.
A graph container for managing solver nodes and edges with type-safe access.
std::shared_ptr< INode > & get_node_ptr_base(const std::string &name)
Retrieve a node by name as a shared pointer to the base interface.
std::shared_ptr< T > get_edge_ptr(const std::string &name)
Get a typed shared pointer to an edge by name.
std::shared_ptr< T > register_edge(const std::string &name, T &&edge)
Register an edge with automatic type deduction and shared pointer creation.
std::shared_ptr< IEdge > & get_edge_ptr_base(const std::string &name)
Retrieve an edge by name as a shared pointer to the base interface.
std::shared_ptr< T > register_node(const std::string &name, T &&node)
Register a node with automatic type deduction and shared pointer creation.
T & get_node_ref(const std::string &name)
Get a typed reference to a node by name.
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.
namespace for basic c++ utilities
T & get_check_ref(const std::unique_ptr< T > &ptr, SourceLocation loc=SourceLocation())
Takes a std::unique_ptr and returns a reference to the object it holds. It throws a std::runtime_erro...
Definition memory.hpp:112
void throw_unimplemented(SourceLocation loc=SourceLocation{})
Throw a std::runtime_error saying that the function is unimplemented.
namespace for math utility
Definition AABB.hpp:26
namespace for the main framework
Definition __init__.py:1
sph kernels
shambase::details::BasicStackEntry StackEntry
Alias for shambase::details::BasicStackEntry.
A class that references multiple buffers or similar objects.
Definition MultiRef.hpp:33
shammodels::ExtForceConfig< Tvec > ExtForceConfig
External force configuration.
Patch object that contain generic patch information.
Definition Patch.hpp:33
u64 id_patch
unique key that identify the patch
Definition Patch.hpp:86