SPH
Presets.cpp
Go to the documentation of this file.
1 #include "run/jobs/Presets.h"
2 #include "io/FileSystem.h"
3 #include "run/jobs/GeometryJobs.h"
4 #include "run/jobs/InitialConditionJobs.h"
5 #include "run/jobs/IoJobs.h"
6 #include "run/jobs/MaterialJobs.h"
7 #include "run/jobs/ParticleJobs.h"
8 #include "run/jobs/SimulationJobs.h"
9 #include "sph/Materials.h"
10 #include "thread/CheckFunction.h"
11 
12 NAMESPACE_SPH_BEGIN
13 
14 namespace Presets {
15 
16 static RegisterEnum<Id> sPresetsId({
17  { Id::COLLISION, "collision", "Simple simulation of a two-body collision." },
18  { Id::FRAGMENTATION_REACCUMULATION,
19  "fragmentation_and_reaccumulation",
20  "SPH simulation of an impact and fragmentation followed by an N-body simulation of gravitational "
21  "reaccumulation of fragments." },
22  { Id::CRATERING,
23  "cratering",
24  "Meteoroid impact to a horizontal surface enclosed by boundary conditions." },
25  { Id::PLANETESIMAL_MERGING,
26  "planetesimal_merging",
27  "Two equal-sized planetesimals with iron core colliding and merging." },
28  { Id::GALAXY_COLLISION, "galaxy_collision", "Simulation of two interacting galaxies." },
29  { Id::ACCRETION_DISK,
30  "accretion_disk",
31  "Gas giant orbiting a neutron star and creating an accretion disk." },
32  { Id::SOLAR_SYSTEM,
33  "solar_system",
34  "N-body simulation of the Sun and eight planets of our Solar System." },
35 });
36 
37 }
38 
39 SharedPtr<JobNode> Presets::make(const Id id, UniqueNameManager& nameMgr, const Size particleCnt) {
40  switch (id) {
41  case Id::COLLISION:
42  return makeAsteroidCollision(nameMgr, particleCnt);
43  case Id::FRAGMENTATION_REACCUMULATION:
44  return makeFragmentationAndReaccumulation(nameMgr, particleCnt);
45  case Id::CRATERING:
46  return makeCratering(nameMgr, particleCnt);
47  case Id::PLANETESIMAL_MERGING:
48  return makePlanetesimalMerging(nameMgr, particleCnt);
49  case Id::GALAXY_COLLISION:
50  return makeGalaxyCollision(nameMgr, particleCnt);
51  case Id::ACCRETION_DISK:
52  return makeAccretionDisk(nameMgr, particleCnt);
53  case Id::SOLAR_SYSTEM:
54  return makeSolarSystem(nameMgr);
55  default:
56  NOT_IMPLEMENTED;
57  }
58 }
59 
60 SharedPtr<JobNode> Presets::makeAsteroidCollision(UniqueNameManager& nameMgr, const Size particleCnt) {
61  SharedPtr<JobNode> targetMaterial = makeNode<MaterialJob>(nameMgr.getName("material"), EMPTY_SETTINGS);
62  SharedPtr<JobNode> impactorMaterial =
63  makeNode<DisableDerivativeCriterionJob>(nameMgr.getName("optimize impactor"));
64  targetMaterial->connect(impactorMaterial, "material");
65 
66  SharedPtr<JobNode> targetIc = makeNode<MonolithicBodyIc>(nameMgr.getName("target body"));
67  VirtualSettings targetSettings = targetIc->getSettings();
68  targetSettings.set("useMaterialSlot", true);
69  targetSettings.set("body.radius", 50._f); // D=100km
70  targetSettings.set("particles.count", int(particleCnt));
71 
72  SharedPtr<JobNode> impactorIc = makeNode<ImpactorIc>(nameMgr.getName("impactor body"));
73  VirtualSettings impactorSettings = impactorIc->getSettings();
74  impactorSettings.set("useMaterialSlot", true);
75  impactorSettings.set("body.radius", 10._f); // D=20km
76  targetMaterial->connect(targetIc, "material");
77  impactorMaterial->connect(impactorIc, "material");
78  targetIc->connect(impactorIc, "target");
79 
80  CollisionGeometrySettings geometry;
81  SharedPtr<JobNode> setup = makeNode<CollisionGeometrySetup>(nameMgr.getName("geometry"), geometry);
82  targetIc->connect(setup, "target");
83  impactorIc->connect(setup, "impactor");
84 
85  SharedPtr<JobNode> frag = makeNode<SphJob>(nameMgr.getName("fragmentation"), EMPTY_SETTINGS);
86  setup->connect(frag, "particles");
87 
88  return frag;
89 }
90 
91 SharedPtr<JobNode> Presets::makeFragmentationAndReaccumulation(UniqueNameManager& nameMgr,
92  const Size particleCnt) {
93  makeNode<SphereJob>("dummy");
94 
95  SharedPtr<JobNode> targetMaterial = makeNode<MaterialJob>(nameMgr.getName("material"), EMPTY_SETTINGS);
96  SharedPtr<JobNode> impactorMaterial =
97  makeNode<DisableDerivativeCriterionJob>(nameMgr.getName("optimize impactor"));
98  targetMaterial->connect(impactorMaterial, "material");
99 
100  SharedPtr<JobNode> targetIc = makeNode<MonolithicBodyIc>(nameMgr.getName("target body"));
101  VirtualSettings targetSettings = targetIc->getSettings();
102  targetSettings.set("useMaterialSlot", true);
103  targetSettings.set("body.radius", 50._f); // D=100km
104  targetSettings.set("particles.count", int(particleCnt));
105 
106  SharedPtr<JobNode> impactorIc = makeNode<ImpactorIc>(nameMgr.getName("impactor body"));
107  VirtualSettings impactorSettings = impactorIc->getSettings();
108  impactorSettings.set("useMaterialSlot", true);
109  impactorSettings.set("body.radius", 10._f); // D=20km
110  targetMaterial->connect(targetIc, "material");
111  impactorMaterial->connect(impactorIc, "material");
112  targetIc->connect(impactorIc, "target");
113 
114  SharedPtr<JobNode> stabTarget =
115  makeNode<SphStabilizationJob>(nameMgr.getName("stabilize target"), EMPTY_SETTINGS);
116  targetIc->connect(stabTarget, "particles");
117 
118  CollisionGeometrySettings geometry;
119  SharedPtr<JobNode> setup = makeNode<CollisionGeometrySetup>(nameMgr.getName("geometry"), geometry);
120  stabTarget->connect(setup, "target");
121  impactorIc->connect(setup, "impactor");
122 
123  SharedPtr<JobNode> frag = makeNode<SphJob>(nameMgr.getName("fragmentation"), EMPTY_SETTINGS);
124  setup->connect(frag, "particles");
125  SharedPtr<JobNode> handoff = makeNode<SmoothedToSolidHandoff>(nameMgr.getName("handoff"));
126  frag->connect(handoff, "particles");
127 
128  SharedPtr<JobNode> reacc = makeNode<NBodyJob>(nameMgr.getName("reaccumulation"), EMPTY_SETTINGS);
129  handoff->connect(reacc, "particles");
130 
131  return reacc;
132 }
133 
134 SharedPtr<JobNode> Presets::makeCratering(UniqueNameManager& nameMgr, const Size particleCnt) {
135  CHECK_FUNCTION(CheckFunction::NO_THROW);
136 
137  SharedPtr<JobNode> targetMaterial = makeNode<MaterialJob>(nameMgr.getName("material"), EMPTY_SETTINGS);
138 
139  const Vector targetSize(100._f, 30._f, 100._f); // in km
140  const Vector domainSize(100._f, 100._f, 100._f); // in km
141  const Flags<ForceEnum> forces = ForceEnum::PRESSURE | ForceEnum::SOLID_STRESS;
142  const Flags<TimeStepCriterionEnum> criteria = TimeStepCriterionEnum::COURANT |
143  TimeStepCriterionEnum::DIVERGENCE |
144  TimeStepCriterionEnum::DERIVATIVES;
145 
146  SharedPtr<JobNode> domain = makeNode<BlockJob>(nameMgr.getName("boundary"));
147  VirtualSettings domainSettings = domain->getSettings();
148  domainSettings.set("dimensions", domainSize);
149  domainSettings.set("center", 0.5_f * (domainSize - targetSize));
150 
151  SharedPtr<JobNode> targetIc = makeNode<MonolithicBodyIc>(nameMgr.getName("target body"));
152  VirtualSettings targetSettings = targetIc->getSettings();
153  targetSettings.set("useMaterialSlot", true);
154  targetSettings.set("particles.count", int(particleCnt));
155  targetSettings.set(BodySettingsId::BODY_SHAPE_TYPE, EnumWrapper(DomainEnum::BLOCK));
156  targetSettings.set(BodySettingsId::BODY_DIMENSIONS, targetSize);
157  targetMaterial->connect(targetIc, "material");
158 
159  SharedPtr<JobNode> stabilizeTarget = makeNode<SphStabilizationJob>(nameMgr.getName("stabilize target"));
160  VirtualSettings stabilizeSettings = stabilizeTarget->getSettings();
161  stabilizeSettings.set(RunSettingsId::RUN_END_TIME, 40._f);
162  stabilizeSettings.set(RunSettingsId::DOMAIN_BOUNDARY, EnumWrapper(BoundaryEnum::GHOST_PARTICLES));
163  stabilizeSettings.set(RunSettingsId::SPH_SOLVER_FORCES, EnumWrapper(ForceEnum(forces.value())));
164  stabilizeSettings.set(RunSettingsId::FRAME_CONSTANT_ACCELERATION, Vector(0._f, -10._f, 0._f));
165  stabilizeSettings.set(
166  RunSettingsId::TIMESTEPPING_CRITERION, EnumWrapper(TimeStepCriterionEnum(criteria.value())));
167  targetIc->connect(stabilizeTarget, "particles");
168  domain->connect(stabilizeTarget, "boundary");
169 
170  SharedPtr<JobNode> impactorIc = makeNode<ImpactorIc>(nameMgr.getName("impactor body"));
171  VirtualSettings impactorSettings = impactorIc->getSettings();
172  impactorSettings.set("useMaterialSlot", true);
173 
174  const Float impactorRadius = 2._f;
175  impactorSettings.set("body.radius", impactorRadius); // D=4km
176 
177  SharedPtr<JobNode> impactorMaterial =
178  makeNode<DisableDerivativeCriterionJob>(nameMgr.getName("optimize impactor"));
179  targetMaterial->connect(impactorMaterial, "material");
180 
181  impactorMaterial->connect(impactorIc, "material");
182  targetIc->connect(impactorIc, "target");
183 
184  SharedPtr<JobNode> merger = makeNode<JoinParticlesJob>("merger");
185  VirtualSettings mergerSettings = merger->getSettings();
186  mergerSettings.set("offset", Vector(0._f, 50._f, 0._f)); // 50km
187  mergerSettings.set("velocity", Vector(0._f, -5._f, 0._f)); // 5km/s
188  mergerSettings.set("unique_flags", true); // separate the bodies
189  stabilizeTarget->connect(merger, "particles A");
190  impactorIc->connect(merger, "particles B");
191 
192  SharedPtr<JobNode> cratering = makeNode<SphJob>(nameMgr.getName("cratering"), EMPTY_SETTINGS);
193  VirtualSettings crateringSettings = cratering->getSettings();
194  crateringSettings.set(RunSettingsId::RUN_END_TIME, 60._f);
195  crateringSettings.set(RunSettingsId::DOMAIN_BOUNDARY, EnumWrapper(BoundaryEnum::GHOST_PARTICLES));
196  crateringSettings.set(RunSettingsId::SPH_SOLVER_FORCES, EnumWrapper(ForceEnum(forces.value())));
197  crateringSettings.set(RunSettingsId::FRAME_CONSTANT_ACCELERATION, Vector(0._f, -10._f, 0._f));
198  stabilizeSettings.set(
199  RunSettingsId::TIMESTEPPING_CRITERION, EnumWrapper(TimeStepCriterionEnum(criteria.value())));
200 
201  merger->connect(cratering, "particles");
202  domain->connect(cratering, "boundary");
203 
204  return cratering;
205 }
206 
207 SharedPtr<JobNode> Presets::makePlanetesimalMerging(UniqueNameManager& nameMgr, const Size particleCnt) {
208  SharedPtr<JobNode> planetesimal = makeNode<DifferentiatedBodyIc>(nameMgr.getName("planetesimal"));
209  VirtualSettings planetSettings = planetesimal->getSettings();
210  planetSettings.set(BodySettingsId::PARTICLE_COUNT, int(particleCnt));
211 
212  SharedPtr<JobNode> olivine =
213  makeNode<MaterialJob>(nameMgr.getName("olivine"), getMaterial(MaterialEnum::OLIVINE)->getParams());
214  olivine->getSettings().set(BodySettingsId::RHEOLOGY_YIELDING, EnumWrapper(YieldingEnum::NONE));
215  SharedPtr<JobNode> iron =
216  makeNode<MaterialJob>(nameMgr.getName("iron"), getMaterial(MaterialEnum::IRON)->getParams());
217  iron->getSettings().set(BodySettingsId::RHEOLOGY_YIELDING, EnumWrapper(YieldingEnum::NONE));
218 
219  SharedPtr<JobNode> surface = makeNode<SphereJob>("surface sphere");
220  surface->getSettings().set("radius", 1500._f); // km
221 
222  SharedPtr<JobNode> core = makeNode<SphereJob>("core sphere");
223  core->getSettings().set("radius", 750._f); // km
224 
225  surface->connect(planetesimal, "base shape");
226  olivine->connect(planetesimal, "base material");
227 
228  core->connect(planetesimal, "shape 1");
229  iron->connect(planetesimal, "material 1");
230 
231  SharedPtr<JobNode> equilibrium = makeNode<EquilibriumIc>("hydrostatic equilibrium");
232  planetesimal->connect(equilibrium, "particles");
233 
234  SharedPtr<JobNode> stab = makeNode<SphStabilizationJob>(nameMgr.getName("stabilize"));
235  VirtualSettings stabSettings = stab->getSettings();
236  stabSettings.set(RunSettingsId::RUN_END_TIME, 1000._f);
237  const TimeStepCriterionEnum criteria = TimeStepCriterionEnum::COURANT;
238  stabSettings.set(RunSettingsId::TIMESTEPPING_CRITERION, EnumWrapper(criteria));
239  equilibrium->connect(stab, "particles");
240 
241  SharedPtr<JobNode> merger = makeNode<JoinParticlesJob>(nameMgr.getName("merge"));
242  VirtualSettings mergerSettings = merger->getSettings();
243  mergerSettings.set("offset", Vector(5000._f, 1500._f, 0._f));
244  mergerSettings.set("velocity", Vector(-2.5_f, 0._f, 0._f));
245  mergerSettings.set("com", true);
246  mergerSettings.set("unique_flags", true);
247 
248  stab->connect(merger, "particles A");
249  stab->connect(merger, "particles B");
250 
251  SharedPtr<JobNode> sim = makeNode<SphJob>(nameMgr.getName("impact simulation"));
252  VirtualSettings simSettings = sim->getSettings();
253  simSettings.set(RunSettingsId::RUN_END_TIME, 15000._f);
254  simSettings.set(RunSettingsId::TIMESTEPPING_CRITERION, EnumWrapper(criteria));
255  merger->connect(sim, "particles");
256 
257  return sim;
258 }
259 
260 SharedPtr<JobNode> Presets::makeGalaxyCollision(UniqueNameManager& nameMgr, const Size particleCnt) {
261  SharedPtr<JobNode> galaxyIc = makeNode<GalaxyIc>(nameMgr.getName("galaxy"));
262  VirtualSettings galaxySettings = galaxyIc->getSettings();
263  galaxySettings.set(GalaxySettingsId::PARTICLE_RADIUS, 0.01_f);
264  galaxySettings.set(GalaxySettingsId::DISK_PARTICLE_COUNT, int(particleCnt) / 2);
265  galaxySettings.set(GalaxySettingsId::BULGE_PARTICLE_COUNT, int(particleCnt) / 4);
266  galaxySettings.set(GalaxySettingsId::HALO_PARTICLE_COUNT, int(particleCnt) / 4);
267 
268  SharedPtr<JobNode> merger = makeNode<JoinParticlesJob>(nameMgr.getName("merge"));
269  VirtualSettings mergerSettings = merger->getSettings();
270  mergerSettings.set("offset", Vector(0.01_f, 0._f, 0._f));
271  mergerSettings.set("velocity", Vector(0._f, 0.0005_f, 0._f));
272  mergerSettings.set("com", true);
273  mergerSettings.set("unique_flags", true);
274 
275  SharedPtr<JobNode> rotator = makeNode<TransformParticlesJob>(nameMgr.getName("rotator"));
276  VirtualSettings rotatorSettings = rotator->getSettings();
277  rotatorSettings.set("yaw", 30._f); // 30deg
278 
279  galaxyIc->connect(merger, "particles A");
280  galaxyIc->connect(rotator, "particles");
281  rotator->connect(merger, "particles B");
282 
283 
284  RunSettings settings = EMPTY_SETTINGS;
285  settings.set(RunSettingsId::COLLISION_HANDLER, CollisionHandlerEnum::ELASTIC_BOUNCE)
286  .set(RunSettingsId::COLLISION_OVERLAP, OverlapEnum::REPEL)
287  .set(RunSettingsId::COLLISION_RESTITUTION_NORMAL, 1._f)
288  .set(RunSettingsId::RUN_END_TIME, 30._f)
289  .set(RunSettingsId::TIMESTEPPING_DERIVATIVE_FACTOR, 1._f)
290  .set(RunSettingsId::GRAVITY_CONSTANT,
291  1._f); // should be already provided by GalaxyIc, but doesnt hurt settings explicitly
292  SharedPtr<JobNode> run = makeNode<NBodyJob>(nameMgr.getName("N-body simulation"), settings);
293  merger->connect(run, "particles");
294  return run;
295 }
296 
297 SharedPtr<JobNode> Presets::makeAccretionDisk(UniqueNameManager& nameMgr, const Size particleCnt) {
298  SharedPtr<JobNode> starIc = makeNode<MonolithicBodyIc>(nameMgr.getName("gas giant"));
299  VirtualSettings starSettings = starIc->getSettings();
300  starSettings.set(BodySettingsId::PARTICLE_COUNT, int(particleCnt));
301  starSettings.set(BodySettingsId::BODY_RADIUS, 200000._f); // km
302  starSettings.set(BodySettingsId::DENSITY, 20._f); // kg/m^3
303  starSettings.set(BodySettingsId::EOS, EnumWrapper(EosEnum::IDEAL_GAS));
304  starSettings.set(BodySettingsId::RHEOLOGY_YIELDING, EnumWrapper(YieldingEnum::NONE));
305 
306  SharedPtr<JobNode> equilibriumIc = makeNode<EquilibriumIc>(nameMgr.getName("hydrostatic equilibrium"));
307  starIc->connect(equilibriumIc, "particles");
308 
309  SharedPtr<JobNode> nsIc = makeNode<SingleParticleIc>(nameMgr.getName("neutron star"));
310  VirtualSettings nsSettings = nsIc->getSettings();
311  nsSettings.set("radius", 0.04_f); // R_sun
312 
313  SharedPtr<JobNode> join = makeNode<JoinParticlesJob>(nameMgr.getName("geometry setup"));
314  VirtualSettings joinSettings = join->getSettings();
315  joinSettings.set("offset", Vector(1.e6_f, 0._f, 0._f));
316  joinSettings.set("velocity", Vector(0._f, 250._f, 0._f));
317  joinSettings.set("com", true);
318  equilibriumIc->connect(join, "particles A");
319  nsIc->connect(join, "particles B");
320 
321  SharedPtr<JobNode> sim = makeNode<SphJob>(nameMgr.getName("accretion"), EMPTY_SETTINGS);
322  VirtualSettings simSettings = sim->getSettings();
323  simSettings.set(RunSettingsId::TIMESTEPPING_MAX_TIMESTEP, 50._f);
324  simSettings.set(RunSettingsId::RUN_END_TIME, 28800._f);
325  const Flags<ForceEnum> forces = ForceEnum::PRESSURE | ForceEnum::SELF_GRAVITY;
326  simSettings.set(RunSettingsId::SPH_SOLVER_FORCES, EnumWrapper(ForceEnum(forces.value())));
327 
328  join->connect(sim, "particles");
329  return sim;
330 }
331 
332 /*static void setPositionAndVelocity(VirtualSettings& settings, const Float radius, const Float longitude) {
333  const Float vel = sqrt(Constants::gravity * Constants::M_sun / (radius * Constants::au));
334  const Float l = longitude * DEG_TO_RAD + vel / (radius * Constants::au) * 3._f * Constants::year;
335  const Vector dir = Vector(cos(l), sin(l), 0._f);
336  settings.set("r0", radius * Constants::au / Constants::R_sun * dir);
337  settings.set("v0", vel * Constants::year / Constants::R_sun * Vector(-dir[Y], dir[X], 0._f));
338 }*/
339 
340 // Ephemeris at epoch K20CH
341 StaticArray<Vector, 8> POSITIONS = {
342  Vector(-8.928734732644719e-2, -4.521325453222446e-1, -2.975182102295437e-2),
343  Vector(-6.441236962991079e-1, -3.314276376252449e-1, 3.226254091757653e-2),
344  Vector(7.549485485202402e-2, 9.867433026966754e-1, 5.784067376482213e-5),
345  Vector(7.910150731229694e-1, 1.264441562325783e0, 6.907352037330410e-3),
346  Vector(2.944626847316137e0, -4.154019886078014e0, -4.864670549497938e-2),
347  Vector(5.418279655781740e0, -8.381621945307499e0, -6.997483972704878e-2),
348  Vector(1.538095560420909e1, 1.242451334531269e1, -1.531172265021136e-1),
349  Vector(2.944592389131131e1, -5.272456275707134e0, -5.700349742119496e-1),
350 };
351 StaticArray<Vector, 8> VELOCITIES = {
352  Vector(2.203479749687471e-2, -3.580432587616751e-3, -2.313817126869404e-3),
353  Vector(9.315663381232362e-3, -1.797621186456914e-2, -7.843669810993209e-4),
354  Vector(-1.743861165458079e-2, 1.361273813138455e-3, 7.711170058594351e-7),
355  Vector(-1.129568889262675e-2, 8.676624992146748e-3, 4.590908874884053e-4),
356  Vector(6.063442036100106e-3, 4.721743950691111e-3, -1.552093577175655e-4),
357  Vector(4.374201049769948e-3, 3.015429419149447e-3, -2.269352878444703e-4),
358  Vector(-2.500397529553041e-3, 2.876319493906491e-3, 4.298287724104297e-5),
359  Vector(5.329085656143531e-4, 3.108706732834171e-3, -7.657253104891884e-5),
360 };
361 
362 static void setPositionAndVelocity(VirtualSettings& settings, const Size idx) {
363  const Vector r = POSITIONS[idx] * Constants::au / Constants::R_sun;
364  const Vector v =
365  VELOCITIES[idx] * (Constants::au / Constants::day) / (Constants::R_sun / Constants::year);
366  settings.set("r0", r);
367  settings.set("v0", v);
368 }
369 
370 SharedPtr<JobNode> Presets::makeSolarSystem(UniqueNameManager& nameMgr) {
371  // https://aa.quae.nl/en/reken/hemelpositie.html
372  SharedPtr<JobNode> join = makeNode<MultiJoinParticlesJob>(nameMgr.getName("create Solar System"));
373  join->getSettings().set("slot_cnt", 9);
374  SharedPtr<JobNode> sunIc = makeNode<SingleParticleIc>(nameMgr.getName("Sun"));
375  VirtualSettings sunSettings = sunIc->getSettings();
376  sunSettings.set("mass", 1._f);
377  sunSettings.set("radius", 1._f);
378  sunSettings.set("flag", 0);
379  sunIc->connect(join, "particles 1");
380 
381  SharedPtr<JobNode> mercuryIc = makeNode<SingleParticleIc>(nameMgr.getName("Mercury"));
382  VirtualSettings mercurySettings = mercuryIc->getSettings();
383  mercurySettings.set("mass", 3.285e23_f / Constants::M_sun);
384  mercurySettings.set("radius", 2439.7e3_f / Constants::R_sun);
385  mercurySettings.set("flag", 1);
386  setPositionAndVelocity(mercurySettings, 0);
387  // setPositionAndVelocity(mercurySettings, 0.4502213_f, 29.125 + 48.331 + 174.795);
388  mercuryIc->connect(join, "particles 2");
389 
390  SharedPtr<JobNode> venusIc = makeNode<SingleParticleIc>(nameMgr.getName("Venus"));
391  VirtualSettings venusSettings = venusIc->getSettings();
392  venusSettings.set("mass", 4.867e24_f / Constants::M_sun);
393  venusSettings.set("radius", 6051.8e3_f / Constants::R_sun);
394  venusSettings.set("flag", 2);
395  setPositionAndVelocity(venusSettings, 1);
396  // setPositionAndVelocity(venusSettings, 0.7263568_f, 54.884 + 76.680 + 50.416);
397  venusIc->connect(join, "particles 3");
398 
399  SharedPtr<JobNode> earthIc = makeNode<SingleParticleIc>(nameMgr.getName("Earth"));
400  VirtualSettings earthSettings = earthIc->getSettings();
401  earthSettings.set("mass", Constants::M_earth / Constants::M_sun);
402  earthSettings.set("radius", Constants::R_earth / Constants::R_sun);
403  earthSettings.set("flag", 3);
404  setPositionAndVelocity(earthSettings, 2);
405  // setPositionAndVelocity(earthSettings, 1._f, 288.064 + 174.873 + 357.529);
406  earthIc->connect(join, "particles 4");
407 
408  SharedPtr<JobNode> marsIc = makeNode<SingleParticleIc>(nameMgr.getName("Mars"));
409  VirtualSettings marsSettings = marsIc->getSettings();
410  marsSettings.set("mass", 6.39e23_f / Constants::M_sun);
411  marsSettings.set("radius", 3389.5e3_f / Constants::R_sun);
412  marsSettings.set("flag", 4);
413  setPositionAndVelocity(marsSettings, 3);
414  // setPositionAndVelocity(marsSettings, 1.6086343_f, 286.502 + 49.558 + 19.373);
415  marsIc->connect(join, "particles 5");
416 
417  SharedPtr<JobNode> jupiterIc = makeNode<SingleParticleIc>(nameMgr.getName("Jupiter"));
418  VirtualSettings jupiterSettings = jupiterIc->getSettings();
419  jupiterSettings.set("mass", 1.898e27_f / Constants::M_sun);
420  jupiterSettings.set("radius", 69911.e3_f / Constants::R_sun);
421  jupiterSettings.set("flag", 5);
422  setPositionAndVelocity(jupiterSettings, 4);
423  // setPositionAndVelocity(jupiterSettings, 5.0684375_f, 273.867 + 100.464 + 20.020);
424  jupiterIc->connect(join, "particles 6");
425 
426  SharedPtr<JobNode> saturnIc = makeNode<SingleParticleIc>(nameMgr.getName("Saturn"));
427  VirtualSettings saturnSettings = saturnIc->getSettings();
428  saturnSettings.set("mass", 5.683e26_f / Constants::M_sun);
429  saturnSettings.set("radius", 58232.e3_f / Constants::R_sun);
430  saturnSettings.set("flag", 6);
431  setPositionAndVelocity(saturnSettings, 5);
432  // setPositionAndVelocity(saturnSettings, 9.9734145_f, 339.391 + 113.666 + 317.021);
433  saturnIc->connect(join, "particles 7");
434 
435  SharedPtr<JobNode> uranusIc = makeNode<SingleParticleIc>(nameMgr.getName("Uranus"));
436  VirtualSettings uranusSettings = uranusIc->getSettings();
437  uranusSettings.set("mass", 8.681e25_f / Constants::M_sun);
438  uranusSettings.set("radius", 25362e3_f / Constants::R_sun);
439  uranusSettings.set("flag", 7);
440  setPositionAndVelocity(uranusSettings, 6);
441  // setPositionAndVelocity(uranusSettings, 19.7612021_f, 98.999 + 74.006 + 141.050);
442  uranusIc->connect(join, "particles 8");
443 
444  SharedPtr<JobNode> neptuneIc = makeNode<SingleParticleIc>(nameMgr.getName("Neptune"));
445  VirtualSettings neptuneSettings = neptuneIc->getSettings();
446  neptuneSettings.set("mass", 1.024e26_f / Constants::M_sun);
447  neptuneSettings.set("radius", 24622e3_f / Constants::R_sun);
448  neptuneSettings.set("flag", 8);
449  setPositionAndVelocity(neptuneSettings, 7);
450  // setPositionAndVelocity(neptuneSettings, 29.9254883_f, 276.340 + 131.784 + 256.225);
451  neptuneIc->connect(join, "particles 9");
452 
453  SharedPtr<JobNode> sim = makeNode<NBodyJob>(nameMgr.getName("orbital simulation"), EMPTY_SETTINGS);
454  join->connect(sim, "particles");
455  VirtualSettings simSettings = sim->getSettings();
456  simSettings.set(RunSettingsId::TIMESTEPPING_MAX_TIMESTEP, 3600._f);
457  simSettings.set(RunSettingsId::RUN_END_TIME, Constants::year * 100._f);
458  simSettings.set(RunSettingsId::RUN_LOGGER_VERBOSITY, 0);
459  return sim;
460 }
461 
462 NAMESPACE_SPH_END
NOT_IMPLEMENTED
#define NOT_IMPLEMENTED
Helper macro marking missing implementation.
Definition: Assert.h:100
NAMESPACE_SPH_BEGIN
NAMESPACE_SPH_BEGIN
Definition: BarnesHut.cpp:13
CheckFunction.h
Helper functions to check the internal consistency of the code.
CheckFunction::NO_THROW
@ NO_THROW
Function cannot throw exceptions.
CHECK_FUNCTION
#define CHECK_FUNCTION(flags)
Definition: CheckFunction.h:40
Size
uint32_t Size
Integral type used to index arrays (by default).
Definition: Globals.h:16
Float
double Float
Precision used withing the code. Use Float instead of float or double where precision is important.
Definition: Globals.h:13
getMaterial
AutoPtr< IMaterial > getMaterial(const MaterialEnum type)
Definition: Materials.cpp:91
Materials.h
SPH-specific implementation of particle materials.
NAMESPACE_SPH_END
#define NAMESPACE_SPH_END
Definition: Object.h:12
VELOCITIES
StaticArray< Vector, 8 > VELOCITIES
Definition: Presets.cpp:351
POSITIONS
StaticArray< Vector, 8 > POSITIONS
Definition: Presets.cpp:341
Vector
BasicVector< Float > Vector
Definition: Vector.h:539
Flags
Wrapper of an integral value providing functions for reading and modifying individual bits.
Definition: Flags.h:20
Flags::value
INLINE TValue value() const
Returns the underlying value.
Definition: Flags.h:118
JobNode::connect
void connect(SharedPtr< JobNode > dependent, const std::string &slotName)
Connects this node to given dependent node.
Definition: Node.cpp:60
JobNode::getSettings
VirtualSettings getSettings() const
Returns settings object allowing to access and modify the state of the job.
Definition: Node.cpp:39
Settings::set
Settings & set(const TEnum idx, TValue &&value, std::enable_if_t<!std::is_enum< std::decay_t< TValue >>::value, int >=0)
Saves a value into the settings.
Definition: Settings.h:226
StaticArray
Array with fixed number of allocated elements.
Definition: StaticArray.h:19
UniqueNameManager::getName
std::string getName(const std::string &name)
Definition: StringUtils.cpp:247
VirtualSettings
Holds a map of virtual entries, associated with a unique name.
Definition: VirtualSettings.h:229
VirtualSettings::set
void set(const std::string &key, const IVirtualEntry::Value &value)
Modifies an existing entry in the settings.
Definition: VirtualSettings.cpp:79
ForceEnum
ForceEnum
Definition: Settings.h:658
ForceEnum::PRESSURE
@ PRESSURE
Use force from pressure gradient in the solver.
ForceEnum::SELF_GRAVITY
@ SELF_GRAVITY
Use gravitational force in the model.
YieldingEnum::NONE
@ NONE
Gass or material with no stress tensor.
TimeStepCriterionEnum
TimeStepCriterionEnum
Definition: Settings.h:567
TimeStepCriterionEnum::DIVERGENCE
@ DIVERGENCE
Time step computed from velocity divergence.
TimeStepCriterionEnum::DERIVATIVES
@ DERIVATIVES
Time step computed by limiting value-to-derivative ratio of quantiites.
TimeStepCriterionEnum::COURANT
@ COURANT
Time step determined using CFL condition.
EMPTY_SETTINGS
const EmptySettingsTag EMPTY_SETTINGS
Definition: Settings.h:32
OverlapEnum::REPEL
@ REPEL
Particles are shifted until no overlap happens.
EosEnum::IDEAL_GAS
@ IDEAL_GAS
Equation of state for ideal gas.
BodySettingsId::PARTICLE_COUNT
@ PARTICLE_COUNT
Number of SPH particles in the body.
BodySettingsId::DENSITY
@ DENSITY
Density at zero pressure.
BodySettingsId::EOS
@ EOS
Equation of state for this material, see EosEnum for options.
BodySettingsId::RHEOLOGY_YIELDING
@ RHEOLOGY_YIELDING
Model of stress reducing used within the rheological model.
BoundaryEnum::GHOST_PARTICLES
@ GHOST_PARTICLES
Create ghosts to keep particles inside domain.
RunSettingsId::TIMESTEPPING_MAX_TIMESTEP
@ TIMESTEPPING_MAX_TIMESTEP
RunSettingsId::COLLISION_HANDLER
@ COLLISION_HANDLER
Specifies how the collisions of particles should be handler; see CollisionHandlerEnum.
RunSettingsId::SPH_SOLVER_FORCES
@ SPH_SOLVER_FORCES
List of forces to compute by the solver.
RunSettingsId::TIMESTEPPING_DERIVATIVE_FACTOR
@ TIMESTEPPING_DERIVATIVE_FACTOR
Multiplicative factor k for the derivative criterion; dt = k * v / dv.
RunSettingsId::COLLISION_OVERLAP
@ COLLISION_OVERLAP
Specifies how particle overlaps should be handled.
RunSettingsId::RUN_LOGGER_VERBOSITY
@ RUN_LOGGER_VERBOSITY
Number specifying log verbosity. Can be between 0 and 3, going from least to most verbose.
RunSettingsId::DOMAIN_BOUNDARY
@ DOMAIN_BOUNDARY
Type of boundary conditions.
RunSettingsId::GRAVITY_CONSTANT
@ GRAVITY_CONSTANT
Gravitational constant. To be generalized.
RunSettingsId::FRAME_CONSTANT_ACCELERATION
@ FRAME_CONSTANT_ACCELERATION
RunSettingsId::COLLISION_RESTITUTION_NORMAL
@ COLLISION_RESTITUTION_NORMAL
DomainEnum::BLOCK
@ BLOCK
Block with edge sizes given by vector.
Constants::au
constexpr Float au
Astronomical unit (exactly)
Definition: Constants.h:38
Constants::R_earth
constexpr Float R_earth
Earth radius.
Definition: Constants.h:60
Constants::day
constexpr Float day
Number of seconds in a day.
Definition: Constants.h:44
Constants::R_sun
constexpr Float R_sun
Solar radius.
Definition: Constants.h:57
Constants::M_earth
constexpr Float M_earth
Earth mass.
Definition: Constants.h:54
Constants::year
constexpr Float year
Number of seconds in a year.
Definition: Constants.h:47
Constants::M_sun
constexpr Float M_sun
Definition: Constants.h:51
Presets::makeFragmentationAndReaccumulation
SharedPtr< JobNode > makeFragmentationAndReaccumulation(UniqueNameManager &nameMgr, const Size particleCnt=10000)
Creates a node tree for collision simulation, consisting of stabilization of the target,...
Definition: Presets.cpp:91
Presets::Id::FRAGMENTATION_REACCUMULATION
@ FRAGMENTATION_REACCUMULATION
Presets::Id::PLANETESIMAL_MERGING
@ PLANETESIMAL_MERGING
Presets::make
SharedPtr< JobNode > make(const Id id, UniqueNameManager &nameMgr, const Size particleCnt=10000)
Creates a node tree for the preset with given ID.
Definition: Presets.cpp:39
Presets::makeAsteroidCollision
SharedPtr< JobNode > makeAsteroidCollision(UniqueNameManager &nameMgr, const Size particleCnt=10000)
Creates a node tree for basic collision simulation.
Definition: Presets.cpp:60
Presets::makeCratering
SharedPtr< JobNode > makeCratering(UniqueNameManager &nameMgr, const Size particleCnt=10000)
Creates a node tree for simulation of cratering.
Definition: Presets.cpp:134
Presets::makeAccretionDisk
SharedPtr< JobNode > makeAccretionDisk(UniqueNameManager &nameMgr, const Size particleCnt=10000)
Creates a node tree for accretion simulation.
Definition: Presets.cpp:297
Presets::makePlanetesimalMerging
SharedPtr< JobNode > makePlanetesimalMerging(UniqueNameManager &nameMgr, const Size particleCnt=10000)
Creates a node tree for simulation of planetesimal collision.
Definition: Presets.cpp:207
Presets::makeGalaxyCollision
SharedPtr< JobNode > makeGalaxyCollision(UniqueNameManager &nameMgr, const Size particleCnt=10000)
Creates a node tree for galaxy collision.
Definition: Presets.cpp:260
Presets::makeSolarSystem
SharedPtr< JobNode > makeSolarSystem(UniqueNameManager &nameMgr)
Creates a node tree for the Solar System.
Definition: Presets.cpp:370
EnumWrapper
Wrapper of an enum.
Definition: Settings.h:37
RegisterEnum
Helper class for adding individual enums to the enum map.
Definition: EnumMap.h:175
Generated by doxygen 1.9.1