cell.h 35 KB
Newer Older
1
/*******************************************************************************
2
 * This file is part of SWIFT.
3
 * Copyright (c) 2012 Pedro Gonnet (pedro.gonnet@durham.ac.uk)
4
5
6
7
 *                    Matthieu Schaller (matthieu.schaller@durham.ac.uk)
 *               2015 Peter W. Draper (p.w.draper@durham.ac.uk)
 *               2016 John A. Regan (john.a.regan@durham.ac.uk)
 *                    Tom Theuns (tom.theuns@durham.ac.uk)
8
 *
9
10
11
12
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
13
 *
14
15
16
17
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
18
 *
19
20
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
21
 *
22
 ******************************************************************************/
23
24
#ifndef SWIFT_CELL_H
#define SWIFT_CELL_H
25

26
27
28
/* Config parameters. */
#include "../config.h"

29
/* Includes. */
30
31
32
#include <stddef.h>

/* Local includes. */
33
#include "align.h"
34
#include "kernel_hydro.h"
Pedro Gonnet's avatar
Pedro Gonnet committed
35
#include "lock.h"
36
#include "multipole.h"
37
#include "part.h"
38
#include "sort_part.h"
39
#include "space.h"
40
#include "task.h"
41
#include "timeline.h"
42

43
/* Avoid cyclic inclusions */
44
struct engine;
45
struct scheduler;
46

47
48
49
/* Max tag size set to 2^29 to take into account some MPI implementations
 * that use 2^31 as the upper bound on MPI tags and the fact that
 * cell_next_tag is multiplied by 2 when passed to an MPI function.
50
51
 * The maximum was lowered by a further factor of 2 to be on the safe side.*/
#define cell_max_tag (1 << 29)
52

53
#define cell_align 128
54

55
56
57
/* Global variables. */
extern int cell_next_tag;

58
59
60
61
/* Struct to temporarily buffer the particle locations and bin id. */
struct cell_buff {
  double x[3];
  int ind;
62
} SWIFT_STRUCT_ALIGN;
63

64
65
66
67
68
69
70
71
72
/* Mini struct to link cells to tasks. Used as a linked list. */
struct link {
  /* The task pointer. */
  struct task *t;

  /* The next pointer. */
  struct link *next;
};

73
74
75
76
77
/**
 * @brief Packed cell for information correct at rebuild time.
 *
 * Contains all the information for a tree walk in a non-local cell.
 */
78
struct pcell {
79
80
81
82
  /*! Hydro variables */
  struct {
    /*! Maximal smoothing length. */
    double h_max;
83

84
85
    /*! Minimal integer end-of-timestep in this cell for hydro tasks */
    integertime_t ti_end_min;
86

87
88
    /*! Maximal integer end-of-timestep in this cell for hydro tasks */
    integertime_t ti_end_max;
89

90
91
    /*! Maximal integer beginning-of-timestep in this cell for hydro tasks */
    integertime_t ti_beg_max;
92

93
    /*! Integer time of the last drift of the #part in this cell */
94
    integertime_t ti_old_part;
95

96
97
    /*! Number of #part in this cell. */
    int count;
98

99
  } hydro;
100

101
102
103
104
  /*! Gravity variables */
  struct {
    /*! This cell's gravity-related tensors */
    struct multipole m_pole;
105

106
107
    /*! Centre of mass. */
    double CoM[3];
108

109
110
    /*! Centre of mass at rebuild time. */
    double CoM_rebuild[3];
111

112
113
    /*! Upper limit of the CoM<->gpart distance. */
    double r_max;
114

115
116
    /*! Upper limit of the CoM<->gpart distance at last rebuild. */
    double r_max_rebuild;
117

118
119
    /*! Minimal integer end-of-timestep in this cell for gravity tasks */
    integertime_t ti_end_min;
Pedro Gonnet's avatar
Pedro Gonnet committed
120

121
122
    /*! Maximal integer end-of-timestep in this cell for gravity tasks */
    integertime_t ti_end_max;
123

124
125
    /*! Maximal integer beginning-of-timestep in this cell for gravity tasks */
    integertime_t ti_beg_max;
126

127
    /*! Integer time of the last drift of the #gpart in this cell */
128
    integertime_t ti_old_part;
129

130
131
    /*! Integer time of the last drift of the #multipole in this cell */
    integertime_t ti_old_multipole;
132

133
    /*! Number of #gpart in this cell. */
134
    int count;
135
136
137

  } grav;

138
139
140
141
142
  /*! Stars variables */
  struct {
    /*! Number of #spart in this cell. */
    int count;

Loic Hausammann's avatar
Loic Hausammann committed
143
144
145
    /*! Maximal smoothing length. */
    double h_max;

146
147
148
    /*! Minimal integer end-of-timestep in this cell for stars tasks */
    integertime_t ti_end_min;

149
150
151
    /*! Maximal integer end-of-timestep in this cell for stars tasks */
    integertime_t ti_end_max;

152
153
154
    /*! Integer time of the last drift of the #spart in this cell */
    integertime_t ti_old_part;

155
156
  } stars;

157
158
159
  /*! Maximal depth in that part of the tree */
  int maxdepth;

160
161
  /*! Relative indices of the cell's progeny. */
  int progeny[8];
162

163
164
165
166
167
#ifdef SWIFT_DEBUG_CHECKS
  /* Cell ID (for debugging) */
  int cellID;
#endif

168
} SWIFT_STRUCT_ALIGN;
169

170
171
172
/**
 * @brief Cell information at the end of a time-step.
 */
173
174
175
struct pcell_step_hydro {
  /*! Minimal integer end-of-timestep in this cell (hydro) */
  integertime_t ti_end_min;
176

177
178
  /*! Minimal integer end-of-timestep in this cell (hydro) */
  integertime_t ti_end_max;
179

180
181
182
  /*! Maximal distance any #part has travelled since last rebuild */
  float dx_max_part;
};
183

184
185
186
struct pcell_step_grav {
  /*! Minimal integer end-of-timestep in this cell (gravity) */
  integertime_t ti_end_min;
187

188
189
190
  /*! Minimal integer end-of-timestep in this cell (gravity) */
  integertime_t ti_end_max;
};
Loic Hausammann's avatar
Loic Hausammann committed
191

192
193
194
struct pcell_step_stars {
  /*! Minimal integer end-of-timestep in this cell (stars) */
  integertime_t ti_end_min;
195

196
197
  /*! Maximal integer end-of-timestep in this cell (stars) */
  integertime_t ti_end_max;
198

199
200
  /*! Maximal distance any #part has travelled since last rebuild */
  float dx_max_part;
201
202
};

203
204
205
206
207
/**
 * @brief Cell within the tree structure.
 *
 * Contains particles, links to tasks, a multipole object and counters.
 */
208
struct cell {
209
  /*! The cell location on the grid. */
210
211
  double loc[3];

212
  /*! The cell dimensions. */
213
  double width[3];
214

215
  /*! Pointers to the next level of cells. */
216
217
  struct cell *progeny[8];

218
219
220
  /*! Linking pointer for "memory management". */
  struct cell *next;

221
  /*! Parent cell. */
222
223
  struct cell *parent;

224
225
226
  /*! Pointer to the top-level cell in a hierarchy */
  struct cell *top;

227
  /*! Super cell, i.e. the highest-level parent cell with *any* task */
228
  struct cell *super;
229

230
231
232
233
  /*! Hydro variables */
  struct {
    /*! Pointer to the #part data. */
    struct part *parts;
234

235
236
    /*! Pointer to the #xpart data. */
    struct xpart *xparts;
237

238
239
    /*! Pointer for the sorted indices. */
    struct entry *sort[13];
240
    struct entry *sortptr;
241

242
243
    /*! Super cell, i.e. the highest-level parent cell that has a hydro
     * pair/self tasks */
244
    struct cell *super;
245

246
247
    /*! The task computing this cell's sorts. */
    struct task *sorts;
248

249
250
    /*! The drift task for parts */
    struct task *drift;
251

252
253
254
255
256
257
258
259
260
    /*! Linked list of the tasks computing this cell's hydro density. */
    struct link *density;

    /* Linked list of the tasks computing this cell's hydro gradients. */
    struct link *gradient;

    /*! Linked list of the tasks computing this cell's hydro forces. */
    struct link *force;

261
262
263
    /*! Linked list of the tasks computing this cell's limiter. */
    struct link *limiter;

264
265
266
267
268
269
270
271
272
273
274
275
    /*! Dependency implicit task for the ghost  (in->ghost->out)*/
    struct task *ghost_in;

    /*! Dependency implicit task for the ghost  (in->ghost->out)*/
    struct task *ghost_out;

    /*! The ghost task itself */
    struct task *ghost;

    /*! The extra ghost task for complex hydro schemes */
    struct task *extra_ghost;

276
277
278
    /*! The task to end the force calculation */
    struct task *end_force;

279
280
281
282
283
    /*! Task for cooling */
    struct task *cooling;

    /*! Task for star formation */
    struct task *star_formation;
284

285
286
    /*! Max smoothing length in this cell. */
    double h_max;
287

288
289
290
    /*! Last (integer) time the cell's part were drifted forward in time. */
    integertime_t ti_old_part;

291
292
    /*! Minimum end of (integer) time step in this cell for hydro tasks. */
    integertime_t ti_end_min;
293

294
295
    /*! Maximum end of (integer) time step in this cell for hydro tasks. */
    integertime_t ti_end_max;
296

297
298
    /*! Maximum beginning of (integer) time step in this cell for hydro tasks.
     */
299
    integertime_t ti_beg_max;
300

301
302
    /*! Spin lock for various uses (#part case). */
    swift_lock_type lock;
303

304
305
    /*! Maximum part movement in this cell since last construction. */
    float dx_max_part;
306

307
308
    /*! Maximum particle movement in this cell since the last sort. */
    float dx_max_sort;
309

310
311
    /*! Values of h_max before the drifts, used for sub-cell tasks. */
    float h_max_old;
312

313
314
315
    /*! Values of dx_max before the drifts, used for sub-cell tasks. */
    float dx_max_part_old;

316
317
    /*! Values of dx_max_sort before the drifts, used for sub-cell tasks. */
    float dx_max_sort_old;
318

319
320
321
    /*! Nr of #part in this cell. */
    int count;

322
323
324
    /*! Nr of #part this cell can hold after addition of new #part. */
    int count_total;

325
326
327
328
329
330
331
332
333
    /*! Number of #part updated in this cell. */
    int updated;

    /*! Number of #part inhibited in this cell. */
    int inhibited;

    /*! Is the #part data of this cell being used in a sub-cell? */
    int hold;

334
335
    /*! Bit mask of sort directions that will be needed in the next timestep. */
    unsigned int requires_sorts;
336

337
338
    /*! Bit mask of sorts that need to be computed for this cell. */
    unsigned int do_sort;
339

340
341
342
    /*! Bit-mask indicating the sorted directions */
    unsigned int sorted;

343
344
    /*! Does this cell need to be drifted (hydro)? */
    char do_drift;
345

346
347
    /*! Do any of this cell's sub-cells need to be drifted (hydro)? */
    char do_sub_drift;
Tom Theuns's avatar
Tom Theuns committed
348

349
350
    /*! Do any of this cell's sub-cells need to be sorted? */
    char do_sub_sort;
351

352
353
354
355
356
357
    /*! Does this cell need to be limited? */
    char do_limiter;

    /*! Do any of this cell's sub-cells need to be limited? */
    char do_sub_limiter;

Matthieu Schaller's avatar
Matthieu Schaller committed
358
#ifdef SWIFT_DEBUG_CHECKS
359

360
361
    /*! Last (integer) time the cell's sort arrays were updated. */
    integertime_t ti_sort;
362

363
#endif
364

365
  } hydro;
366

367
368
369
  /*! Grav variables */
  struct {
    /*! Pointer to the #gpart data. */
370
    struct gpart *parts;
371

372
373
    /*! This cell's multipole. */
    struct gravity_tensors *multipole;
374

375
376
377
    /*! Super cell, i.e. the highest-level parent cell that has a grav pair/self
     * tasks */
    struct cell *super;
378

379
380
381
    /*! The drift task for gparts */
    struct task *drift;

382
383
384
    /*! Implicit task (going up- and down the tree) for the #gpart drifts */
    struct task *drift_out;

385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
    /*! Linked list of the tasks computing this cell's gravity forces. */
    struct link *grav;

    /*! Linked list of the tasks computing this cell's gravity M-M forces. */
    struct link *mm;

    /*! The multipole initialistation task */
    struct task *init;

    /*! Implicit task for the gravity initialisation */
    struct task *init_out;

    /*! Task computing long range non-periodic gravity interactions */
    struct task *long_range;

    /*! Implicit task for the down propagation */
    struct task *down_in;

    /*! Task propagating the mesh forces to the particles */
    struct task *mesh;

    /*! Task propagating the multipole to the particles */
    struct task *down;

409
410
411
    /*! The task to end the force calculation */
    struct task *end_force;

412
413
    /*! Minimum end of (integer) time step in this cell for gravity tasks. */
    integertime_t ti_end_min;
414

415
416
    /*! Maximum end of (integer) time step in this cell for gravity tasks. */
    integertime_t ti_end_max;
417

418
419
420
    /*! Maximum beginning of (integer) time step in this cell for gravity tasks.
     */
    integertime_t ti_beg_max;
421

422
    /*! Last (integer) time the cell's gpart were drifted forward in time. */
423
    integertime_t ti_old_part;
424

425
426
    /*! Last (integer) time the cell's multipole was drifted forward in time. */
    integertime_t ti_old_multipole;
427

428
    /*! Spin lock for various uses (#gpart case). */
429
    swift_lock_type plock;
430

431
432
    /*! Spin lock for various uses (#multipole case). */
    swift_lock_type mlock;
433

434
435
436
    /*! Nr of #gpart in this cell. */
    int count;

437
438
439
    /*! Nr of #gpart this cell can hold after addition of new #gpart. */
    int count_total;

440
    /*! Number of #gpart updated in this cell. */
441
    int updated;
442

443
444
445
    /*! Number of #gpart inhibited in this cell. */
    int inhibited;

446
    /*! Is the #gpart data of this cell being used in a sub-cell? */
447
    int phold;
448

449
450
    /*! Is the #multipole data of this cell being used in a sub-cell? */
    int mhold;
451

452
453
454
    /*! Number of M-M tasks that are associated with this cell. */
    short int nr_mm_tasks;

455
456
    /*! Does this cell need to be drifted (gravity)? */
    char do_drift;
457

458
459
    /*! Do any of this cell's sub-cells need to be drifted (gravity)? */
    char do_sub_drift;
Matthieu Schaller's avatar
Matthieu Schaller committed
460

461
  } grav;
462

463
464
465
466
  /*! Stars variables */
  struct {
    /*! Pointer to the #spart data. */
    struct spart *parts;
467

468
469
470
471
472
    /*! The star ghost task itself */
    struct task *ghost;

    /*! Linked list of the tasks computing this cell's star density. */
    struct link *density;
473

Alexei Borissov's avatar
Alexei Borissov committed
474
475
476
    /*! Linked list of the tasks computing this cell's star feedback. */
    struct link *feedback;

477
    /*! The task computing this cell's sorts before the density. */
478
    struct task *sorts;
Matthieu Schaller's avatar
Matthieu Schaller committed
479

480
    /*! The drift task for sparts */
481
    struct task *drift;
482

483
484
    /*! Implicit tasks marking the entry of the stellar physics block of tasks
     */
485
486
    struct task *stars_in;

487
    /*! Implicit tasks marking the exit of the stellar physics block of tasks */
488
489
    struct task *stars_out;

Loic Hausammann's avatar
Loic Hausammann committed
490
491
492
    /*! Max smoothing length in this cell. */
    double h_max;

493
494
495
    /*! Last (integer) time the cell's spart were drifted forward in time. */
    integertime_t ti_old_part;

496
497
498
    /*! Spin lock for various uses (#spart case). */
    swift_lock_type lock;

499
500
501
    /*! Spin lock for star formation use. */
    swift_lock_type star_formation_lock;

502
503
504
    /*! Nr of #spart in this cell. */
    int count;

505
506
507
    /*! Nr of #spart this cell can hold after addition of new #spart. */
    int count_total;

Loic Hausammann's avatar
Loic Hausammann committed
508
509
510
511
512
513
514
515
516
    /*! Values of h_max before the drifts, used for sub-cell tasks. */
    float h_max_old;

    /*! Maximum part movement in this cell since last construction. */
    float dx_max_part;

    /*! Values of dx_max before the drifts, used for sub-cell tasks. */
    float dx_max_part_old;

Matthieu Schaller's avatar
Matthieu Schaller committed
517
518
519
520
521
522
523
524
525
526
527
    /*! Maximum particle movement in this cell since the last sort. */
    float dx_max_sort;

    /*! Values of dx_max_sort before the drifts, used for sub-cell tasks. */
    float dx_max_sort_old;

    /*! Bit mask of sort directions that will be needed in the next timestep. */
    unsigned int requires_sorts;

    /*! Pointer for the sorted indices. */
    struct entry *sort[13];
528
    struct entry *sortptr;
Matthieu Schaller's avatar
Matthieu Schaller committed
529
530
531
532
533
534
535
536
537
538
539
540
541

    /*! Bit-mask indicating the sorted directions */
    unsigned int sorted;

    /*! Bit mask of sorts that need to be computed for this cell. */
    unsigned int do_sort;

    /*! Do any of this cell's sub-cells need to be sorted? */
    char do_sub_sort;

    /*! Maximum end of (integer) time step in this cell for gravity tasks. */
    integertime_t ti_end_min;

542
543
544
545
546
547
    /*! Maximum end of (integer) time step in this cell for star tasks. */
    integertime_t ti_end_max;

    /*! Maximum beginning of (integer) time step in this cell for star tasks.
     */
    integertime_t ti_beg_max;
548

549
550
    /*! Number of #spart updated in this cell. */
    int updated;
551

552
553
554
    /*! Number of #spart inhibited in this cell. */
    int inhibited;

555
556
    /*! Is the #spart data of this cell being used in a sub-cell? */
    int hold;
557

558
559
560
561
562
563
    /*! Does this cell need to be drifted (stars)? */
    char do_drift;

    /*! Do any of this cell's sub-cells need to be drifted (stars)? */
    char do_sub_drift;

Matthieu Schaller's avatar
Matthieu Schaller committed
564
565
566
567
568
#ifdef SWIFT_DEBUG_CHECKS
    /*! Last (integer) time the cell's sort arrays were updated. */
    integertime_t ti_sort;
#endif

569
  } stars;
570

571
572
573
#ifdef WITH_MPI
  /*! MPI variables */
  struct {
574

575
576
577
    union {
      /* Single list of all send tasks associated with this cell. */
      struct link *send;
578

579
      /* Single list of all recv tasks associated with this cell. */
580
581
      struct link *recv;
    };
582

583
    struct {
584
585
586
587
588
      /* Task receiving spart data. */
      struct task *recv;

      /* Task receiving data (time-step). */
      struct task *recv_ti;
589
590
    } stars;

591
    struct {
592
      /* Task receiving limiter data. */
593
594
595
596
      struct task *recv;

    } limiter;

597
598
599
600
601
602
603
604
605
606
607
    /*! Bit mask of the proxies this cell is registered with. */
    unsigned long long int sendto;

    /*! Pointer to this cell's packed representation. */
    struct pcell *pcell;

    /*! Size of the packed representation */
    int pcell_size;

    /*! MPI tag associated with this cell */
    int tag;
608

609
610
  } mpi;
#endif
611

612
613
  /*! The first kick task */
  struct task *kick1;
614

615
616
  /*! The second kick task */
  struct task *kick2;
617

618
619
620
  /*! The task to compute time-steps */
  struct task *timestep;

621
622
  /*! The task to limit the time-step of inactive particles */
  struct task *timestep_limiter;
623

Loic Hausammann's avatar
Format    
Loic Hausammann committed
624
625
626
  /*! The logger task */
  struct task *logger;

627
628
  /*! Minimum dimension, i.e. smallest edge of this cell (min(width)). */
  float dmin;
629

630
631
632
633
634
635
  /*! ID of the previous owner, e.g. runner. */
  int owner;

  /*! ID of the node this cell lives on. */
  int nodeID;

636
637
638
639
640
641
642
643
644
645
646
647
  /*! Number of tasks that are associated with this cell. */
  short int nr_tasks;

  /*! The depth of this cell in the tree. */
  char depth;

  /*! Is this cell split ? */
  char split;

  /*! The maximal depth of this cell and its progenies */
  char maxdepth;

Loic Hausammann's avatar
Loic Hausammann committed
648
#if defined(SWIFT_DEBUG_CHECKS) || defined(SWIFT_CELL_GRAPH)
649
650
  /* Cell ID (for debugging) */
  int cellID;
Loic Hausammann's avatar
Loic Hausammann committed
651
652
653
#endif

#ifdef SWIFT_DEBUG_CHECKS
654

655
656
657
658
659
660
661
  /*! The list of tasks that have been executed on this cell */
  char tasks_executed[64];

  /*! The list of sub-tasks that have been executed on this cell */
  char subtasks_executed[64];
#endif

662
} SWIFT_STRUCT_ALIGN;
663

664
665
666
667
/* Convert cell location to ID. */
#define cell_getid(cdim, i, j, k) \
  ((int)(k) + (cdim)[2] * ((int)(j) + (cdim)[1] * (int)(i)))

668
/* Function prototypes. */
669
670
void cell_split(struct cell *c, ptrdiff_t parts_offset, ptrdiff_t sparts_offset,
                struct cell_buff *buff, struct cell_buff *sbuff,
671
                struct cell_buff *gbuff);
672
void cell_sanitize(struct cell *c, int treated);
673
674
675
676
int cell_locktree(struct cell *c);
void cell_unlocktree(struct cell *c);
int cell_glocktree(struct cell *c);
void cell_gunlocktree(struct cell *c);
677
678
int cell_mlocktree(struct cell *c);
void cell_munlocktree(struct cell *c);
679
680
int cell_slocktree(struct cell *c);
void cell_sunlocktree(struct cell *c);
681
int cell_pack(struct cell *c, struct pcell *pc, const int with_gravity);
Matthieu Schaller's avatar
Matthieu Schaller committed
682
683
int cell_unpack(struct pcell *pc, struct cell *c, struct space *s,
                const int with_gravity);
684
685
int cell_pack_tags(const struct cell *c, int *tags);
int cell_unpack_tags(const int *tags, struct cell *c);
686
687
688
689
690
691
int cell_pack_end_step_hydro(struct cell *c, struct pcell_step_hydro *pcell);
int cell_unpack_end_step_hydro(struct cell *c, struct pcell_step_hydro *pcell);
int cell_pack_end_step_grav(struct cell *c, struct pcell_step_grav *pcell);
int cell_unpack_end_step_grav(struct cell *c, struct pcell_step_grav *pcell);
int cell_pack_end_step_stars(struct cell *c, struct pcell_step_stars *pcell);
int cell_unpack_end_step_stars(struct cell *c, struct pcell_step_stars *pcell);
692
693
int cell_pack_multipoles(struct cell *c, struct gravity_tensors *m);
int cell_unpack_multipoles(struct cell *c, struct gravity_tensors *m);
694
int cell_getsize(struct cell *c);
695
int cell_link_parts(struct cell *c, struct part *parts);
696
int cell_link_gparts(struct cell *c, struct gpart *gparts);
697
int cell_link_sparts(struct cell *c, struct spart *sparts);
698
699
int cell_link_foreign_parts(struct cell *c, struct part *parts);
int cell_link_foreign_gparts(struct cell *c, struct gpart *gparts);
700
int cell_count_parts_for_tasks(const struct cell *c);
701
int cell_count_gparts_for_tasks(const struct cell *c);
702
void cell_clean_links(struct cell *c, void *data);
703
void cell_make_multipoles(struct cell *c, integertime_t ti_current);
704
705
void cell_check_multipole(struct cell *c);
void cell_check_foreign_multipole(const struct cell *c);
706
void cell_clean(struct cell *c);
707
708
void cell_check_part_drift_point(struct cell *c, void *data);
void cell_check_gpart_drift_point(struct cell *c, void *data);
709
void cell_check_spart_drift_point(struct cell *c, void *data);
710
void cell_check_multipole_drift_point(struct cell *c, void *data);
711
void cell_reset_task_counters(struct cell *c);
712
int cell_unskip_hydro_tasks(struct cell *c, struct scheduler *s);
713
int cell_unskip_stars_tasks(struct cell *c, struct scheduler *s);
714
int cell_unskip_gravity_tasks(struct cell *c, struct scheduler *s);
715
void cell_drift_part(struct cell *c, const struct engine *e, int force);
716
void cell_drift_gpart(struct cell *c, const struct engine *e, int force);
717
void cell_drift_spart(struct cell *c, const struct engine *e, int force);
718
void cell_drift_multipole(struct cell *c, const struct engine *e);
719
void cell_drift_all_multipoles(struct cell *c, const struct engine *e);
720
void cell_check_timesteps(struct cell *c);
721
void cell_store_pre_drift_values(struct cell *c);
722
723
void cell_activate_subcell_hydro_tasks(struct cell *ci, struct cell *cj,
                                       struct scheduler *s);
724
725
void cell_activate_subcell_grav_tasks(struct cell *ci, struct cell *cj,
                                      struct scheduler *s);
726
727
void cell_activate_subcell_stars_tasks(struct cell *ci, struct cell *cj,
                                       struct scheduler *s);
728
729
void cell_activate_subcell_external_grav_tasks(struct cell *ci,
                                               struct scheduler *s);
730
void cell_activate_super_spart_drifts(struct cell *c, struct scheduler *s);
731
void cell_activate_drift_part(struct cell *c, struct scheduler *s);
732
void cell_activate_drift_gpart(struct cell *c, struct scheduler *s);
Loic Hausammann's avatar
Loic Hausammann committed
733
void cell_activate_drift_spart(struct cell *c, struct scheduler *s);
734
void cell_activate_hydro_sorts(struct cell *c, int sid, struct scheduler *s);
Loic Hausammann's avatar
Loic Hausammann committed
735
void cell_activate_stars_sorts(struct cell *c, int sid, struct scheduler *s);
736
void cell_activate_limiter(struct cell *c, struct scheduler *s);
737
void cell_clear_drift_flags(struct cell *c, void *data);
738
void cell_clear_limiter_flags(struct cell *c, void *data);
Pedro Gonnet's avatar
Pedro Gonnet committed
739
void cell_set_super_mapper(void *map_data, int num_elements, void *extra_data);
740
741
void cell_check_spart_pos(const struct cell *c,
                          const struct spart *global_sparts);
742
void cell_clear_stars_sort_flags(struct cell *c);
743
int cell_has_tasks(struct cell *c);
744
745
void cell_remove_part(const struct engine *e, struct cell *c, struct part *p,
                      struct xpart *xp);
746
747
748
749
void cell_remove_gpart(const struct engine *e, struct cell *c,
                       struct gpart *gp);
void cell_remove_spart(const struct engine *e, struct cell *c,
                       struct spart *sp);
750
struct spart *cell_add_spart(struct engine *e, struct cell *c);
Matthieu Schaller's avatar
Matthieu Schaller committed
751
752
753
754
struct gpart *cell_convert_part_to_gpart(const struct engine *e, struct cell *c,
                                         struct part *p, struct xpart *xp);
struct gpart *cell_convert_spart_to_gpart(const struct engine *e,
                                          struct cell *c, struct spart *sp);
755
756
struct spart *cell_convert_part_to_spart(struct engine *e, struct cell *c,
                                         struct part *p, struct xpart *xp);
757
void cell_reorder_extra_parts(struct cell *c, const ptrdiff_t parts_offset);
758
759
void cell_reorder_extra_gparts(struct cell *c, struct part *parts,
                               struct spart *sparts);
760
void cell_reorder_extra_sparts(struct cell *c, const ptrdiff_t sparts_offset);
761
762
int cell_can_use_pair_mm(const struct cell *ci, const struct cell *cj,
                         const struct engine *e, const struct space *s);
763
int cell_can_use_pair_mm_rebuild(const struct cell *ci, const struct cell *cj,
Matthieu Schaller's avatar
Matthieu Schaller committed
764
                                 const struct engine *e, const struct space *s);
765

766
/**
Peter W. Draper's avatar
Peter W. Draper committed
767
 * @brief Compute the square of the minimal distance between any two points in
Matthieu Schaller's avatar
Matthieu Schaller committed
768
 * two cells of the same size
769
770
771
772
773
774
 *
 * @param ci The first #cell.
 * @param cj The second #cell.
 * @param periodic Are we using periodic BCs?
 * @param dim The dimensions of the simulation volume
 */
Matthieu Schaller's avatar
Matthieu Schaller committed
775
776
777
__attribute__((always_inline)) INLINE static double cell_min_dist2_same_size(
    const struct cell *restrict ci, const struct cell *restrict cj,
    const int periodic, const double dim[3]) {
778
#ifdef SWIFT_DEBUG_CHECKS
Matthieu Schaller's avatar
Matthieu Schaller committed
779
780
781
  if (ci->width[0] != cj->width[0]) error("Cells of different size!");
  if (ci->width[1] != cj->width[1]) error("Cells of different size!");
  if (ci->width[2] != cj->width[2]) error("Cells of different size!");
782
783
#endif

Matthieu Schaller's avatar
Matthieu Schaller committed
784
785
786
787
788
789
790
791
792
793
794
795
  const double cix_min = ci->loc[0];
  const double ciy_min = ci->loc[1];
  const double ciz_min = ci->loc[2];
  const double cjx_min = cj->loc[0];
  const double cjy_min = cj->loc[1];
  const double cjz_min = cj->loc[2];

  const double cix_max = ci->loc[0] + ci->width[0];
  const double ciy_max = ci->loc[1] + ci->width[1];
  const double ciz_max = ci->loc[2] + ci->width[2];
  const double cjx_max = cj->loc[0] + cj->width[0];
  const double cjy_max = cj->loc[1] + cj->width[1];
796
797
798
799
  const double cjz_max = cj->loc[2] + cj->width[2];

  if (periodic) {
    const double dx = min4(fabs(nearest(cix_min - cjx_min, dim[0])),
Matthieu Schaller's avatar
Matthieu Schaller committed
800
801
802
803
                           fabs(nearest(cix_min - cjx_max, dim[0])),
                           fabs(nearest(cix_max - cjx_min, dim[0])),
                           fabs(nearest(cix_max - cjx_max, dim[0])));

804
    const double dy = min4(fabs(nearest(ciy_min - cjy_min, dim[1])),
Matthieu Schaller's avatar
Matthieu Schaller committed
805
806
807
808
                           fabs(nearest(ciy_min - cjy_max, dim[1])),
                           fabs(nearest(ciy_max - cjy_min, dim[1])),
                           fabs(nearest(ciy_max - cjy_max, dim[1])));

809
    const double dz = min4(fabs(nearest(ciz_min - cjz_min, dim[2])),
Matthieu Schaller's avatar
Matthieu Schaller committed
810
811
812
813
                           fabs(nearest(ciz_min - cjz_max, dim[2])),
                           fabs(nearest(ciz_max - cjz_min, dim[2])),
                           fabs(nearest(ciz_max - cjz_max, dim[2])));

814
815
816
    return dx * dx + dy * dy + dz * dz;

  } else {
Matthieu Schaller's avatar
Matthieu Schaller committed
817
818
819
    const double dx = min(fabs(cix_max - cjx_min), fabs(cix_min - cjx_max));
    const double dy = min(fabs(ciy_max - cjy_min), fabs(ciy_min - cjy_max));
    const double dz = min(fabs(ciz_max - cjz_min), fabs(ciz_min - cjz_max));
820
821
822
823
824

    return dx * dx + dy * dy + dz * dz;
  }
}

825
826
827
828
829
830
831
832
/* Inlined functions (for speed). */

/**
 * @brief Can a sub-pair hydro task recurse to a lower level based
 * on the status of the particles in the cell.
 *
 * @param c The #cell.
 */
Matthieu Schaller's avatar
Matthieu Schaller committed
833
834
__attribute__((always_inline)) INLINE static int
cell_can_recurse_in_pair_hydro_task(const struct cell *c) {
835
836
837
838
  /* Is the cell split ? */
  /* If so, is the cut-off radius plus the max distance the parts have moved */
  /* smaller than the sub-cell sizes ? */
  /* Note: We use the _old values as these might have been updated by a drift */
839
  return c->split && ((kernel_gamma * c->hydro.h_max_old +
840
                       c->hydro.dx_max_part_old) < 0.5f * c->dmin);
841
842
843
844
845
846
847
848
}

/**
 * @brief Can a sub-self hydro task recurse to a lower level based
 * on the status of the particles in the cell.
 *
 * @param c The #cell.
 */
Matthieu Schaller's avatar
Matthieu Schaller committed
849
850
__attribute__((always_inline)) INLINE static int
cell_can_recurse_in_self_hydro_task(const struct cell *c) {
851
  /* Is the cell split and not smaller than the smoothing length? */
852
  return c->split && (kernel_gamma * c->hydro.h_max_old < 0.5f * c->dmin);
853
854
}

855
856
857
858
/**
 * @brief Can a sub-pair star task recurse to a lower level based
 * on the status of the particles in the cell.
 *
loikki's avatar
loikki committed
859
860
 * @param ci The #cell with stars.
 * @param cj The #cell with hydro parts.
861
862
 */
__attribute__((always_inline)) INLINE static int
863
864
cell_can_recurse_in_pair_stars_task(const struct cell *ci,
                                    const struct cell *cj) {
Loic Hausammann's avatar
Loic Hausammann committed
865
866
867
868
  /* Is the cell split ? */
  /* If so, is the cut-off radius plus the max distance the parts have moved */
  /* smaller than the sub-cell sizes ? */
  /* Note: We use the _old values as these might have been updated by a drift */
869
870
871
872
873
  return ci->split && cj->split &&
         ((kernel_gamma * ci->stars.h_max_old + ci->stars.dx_max_part_old) <
          0.5f * ci->dmin) &&
         ((kernel_gamma * cj->hydro.h_max_old + cj->hydro.dx_max_part_old) <
          0.5f * cj->dmin);
874
875
876
877
878
879
880
881
882
883
}

/**
 * @brief Can a sub-self stars task recurse to a lower level based
 * on the status of the particles in the cell.
 *
 * @param c The #cell.
 */
__attribute__((always_inline)) INLINE static int
cell_can_recurse_in_self_stars_task(const struct cell *c) {
Loic Hausammann's avatar
Loic Hausammann committed
884
  /* Is the cell split and not smaller than the smoothing length? */
loikki's avatar
loikki committed
885
  return c->split && (kernel_gamma * c->stars.h_max_old < 0.5f * c->dmin) &&
886
         (kernel_gamma * c->hydro.h_max_old < 0.5f * c->dmin);
887
888
}

889
/**
890
 * @brief Can a pair hydro task associated with a cell be split into smaller
891
892
893
894
 * sub-tasks.
 *
 * @param c The #cell.
 */
895
__attribute__((always_inline)) INLINE static int cell_can_split_pair_hydro_task(
896
897
898
899
900
901
    const struct cell *c) {
  /* Is the cell split ? */
  /* If so, is the cut-off radius with some leeway smaller than */
  /* the sub-cell sizes ? */
  /* Note that since tasks are create after a rebuild no need to take */
  /* into account any part motion (i.e. dx_max == 0 here) */
902
  return c->split &&
903
904
         (space_stretch * kernel_gamma * c->hydro.h_max < 0.5f * c->dmin) &&
         (space_stretch * kernel_gamma * c->stars.h_max < 0.5f * c->dmin);
905
906
907
}

/**
908
 * @brief Can a self hydro task associated with a cell be split into smaller
909
910
911
912
 * sub-tasks.
 *
 * @param c The #cell.
 */
913
__attribute__((always_inline)) INLINE static int cell_can_split_self_hydro_task(
914
915
    const struct cell *c) {
  /* Is the cell split ? */
916
917
  /* If so, is the cut-off radius with some leeway smaller than */
  /* the sub-cell sizes ? */
918
919
  /* Note: No need for more checks here as all the sub-pairs and sub-self */
  /* tasks will be created. So no need to check for h_max */
920
  return c->split &&
921
922
         (space_stretch * kernel_gamma * c->hydro.h_max < 0.5f * c->dmin) &&
         (space_stretch * kernel_gamma * c->stars.h_max < 0.5f * c->dmin);
923
924
}

925
926
927
928
929
930
/**
 * @brief Can a pair gravity task associated with a cell be split into smaller
 * sub-tasks.
 *
 * @param c The #cell.
 */
Matthieu Schaller's avatar
Matthieu Schaller committed
931
932
__attribute__((always_inline)) INLINE static int
cell_can_split_pair_gravity_task(const struct cell *c) {
933
934
  /* Is the cell split and still far from the leaves ? */
  return c->split && ((c->maxdepth - c->depth) > space_subdepth_diff_grav);
935
936
937
938
939
940
941
942
}

/**
 * @brief Can a self gravity task associated with a cell be split into smaller
 * sub-tasks.
 *
 * @param c The #cell.
 */
Matthieu Schaller's avatar
Matthieu Schaller committed
943
944
__attribute__((always_inline)) INLINE static int
cell_can_split_self_gravity_task(const struct cell *c) {
945
946
  /* Is the cell split and still far from the leaves ? */
  return c->split && ((c->maxdepth - c->depth) > space_subdepth_diff_grav);
947
948
}

949
/**
Alexei Borissov's avatar
Alexei Borissov committed
950
951
 * @brief Have gas particles in a pair of cells moved too much and require a
 * rebuild
952
953
954
955
956
 * ?
 *
 * @param ci The first #cell.
 * @param cj The second #cell.
 */
Alexei Borissov's avatar
Alexei Borissov committed
957
958
__attribute__((always_inline)) INLINE static int
cell_need_rebuild_for_hydro_pair(const struct cell *ci, const struct cell *cj) {
959
960
961
  /* Is the cut-off radius plus the max distance the parts in both cells have */
  /* moved larger than the cell size ? */
  /* Note ci->dmin == cj->dmin */
962
963
964
  if (kernel_gamma * max(ci->hydro.h_max, cj->hydro.h_max) +
          ci->hydro.dx_max_part + cj->hydro.dx_max_part >
      cj->dmin) {
965
966
    return 1;
  }
967
  return 0;
968
}
969
/**
Loic Hausammann's avatar
Loic Hausammann committed
970
 * @brief Have star particles in a pair of cells moved too much and require a