cell.h 9.88 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"
Pedro Gonnet's avatar
Pedro Gonnet committed
34
#include "lock.h"
35
#include "multipole.h"
36
#include "part.h"
37
#include "task.h"
38
#include "timeline.h"
39

40
/* Avoid cyclic inclusions */
41
struct engine;
42
struct space;
43
struct scheduler;
44

45
46
47
/* 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.
48
49
 * The maximum was lowered by a further factor of 2 to be on the safe side.*/
#define cell_max_tag (1 << 29)
50

51
#define cell_align 128
52

53
54
55
/* Global variables. */
extern int cell_next_tag;

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

62
63
64
65
66
67
68
69
70
71
/* 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;
};

72
73
74
/* Packed cell. */
struct pcell {

75
  /* Stats on this cell's particles. */
76
  double h_max;
77
  integertime_t ti_end_min, ti_end_max, ti_beg_max, ti_old;
78
79

  /* Number of particles in this cell. */
80
  int count, gcount, scount;
Pedro Gonnet's avatar
Pedro Gonnet committed
81

82
83
  /* tag used for MPI communication. */
  int tag;
84

85
86
  /* Relative indices of the cell's progeny. */
  int progeny[8];
87
88

} SWIFT_STRUCT_ALIGN;
89

90
91
92
93
94
/**
 * @brief Cell within the tree structure.
 *
 * Contains particles, links to tasks, a multipole object and counters.
 */
95
96
struct cell {

97
  /*! The cell location on the grid. */
98
99
  double loc[3];

100
  /*! The cell dimensions. */
101
  double width[3];
102

103
  /*! Max smoothing length in this cell. */
104
105
  double h_max;

106
107
108
  /*! This cell's multipole. */
  struct multipole *multipole;

109
110
  /*! Linking pointer for "memory management". */
  struct cell *next;
111

112
  /*! Pointer to the #part data. */
113
114
  struct part *parts;

115
  /*! Pointer to the #xpart data. */
116
117
  struct xpart *xparts;

118
  /*! Pointer to the #gpart data. */
119
120
  struct gpart *gparts;

121
  /*! Pointer to the #spart data. */
122
  struct spart *sparts;
123

124
  /*! Pointer for the sorted indices. */
125
  struct entry *sort;
126

127
  /*! Pointers to the next level of cells. */
128
129
  struct cell *progeny[8];

130
  /*! Parent cell. */
131
132
  struct cell *parent;

133
  /*! Super cell, i.e. the highest-level parent cell that has pair/self tasks */
134
  struct cell *super;
135

136
  /*! The task computing this cell's sorts. */
137
  struct task *sorts;
138

139
140
  /*! Linked list of the tasks computing this cell's hydro density. */
  struct link *density;
141

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

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

148
149
  /*! Linked list of the tasks computing this cell's gravity forces. */
  struct link *grav;
150

151
152
  /*! The initialistation task */
  struct task *init;
153

154
155
  /*! The ghost task */
  struct task *ghost;
156

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

160
161
162
  /*! The drift task */
  struct task *drift;

163
164
165
166
167
  /*! The first kick task */
  struct task *kick1;

  /*! The second kick task */
  struct task *kick2;
168

169
170
  /*! The task to compute time-steps */
  struct task *timestep;
171

172
  /*! Task constructing the multipole from the particles */
173
174
175
176
  struct task *grav_top_level;

  /*! Task constructing the multipole from the particles */
  struct task *grav_long_range;
Tom Theuns's avatar
Tom Theuns committed
177

178
179
  /*! Task propagating the multipole to the particles */
  struct task *grav_down;
180

181
182
  /*! Task for cooling */
  struct task *cooling;
183

184
185
  /*! Task for source terms */
  struct task *sourceterms;
186

187
#ifdef WITH_MPI
188

189
190
  /* Task receiving data (positions). */
  struct task *recv_xv;
191

192
193
  /* Task receiving data (density). */
  struct task *recv_rho;
194

195
196
  /* Task receiving data (gradient). */
  struct task *recv_gradient;
197

198
199
  /* Task receiving data (time-step). */
  struct task *recv_ti;
200

201
202
  /* Linked list for sending data (positions). */
  struct link *send_xv;
203

204
205
  /* Linked list for sending data (density). */
  struct link *send_rho;
206

207
208
209
210
211
  /* Linked list for sending data (gradient). */
  struct link *send_gradient;

  /* Linked list for sending data (time-step). */
  struct link *send_ti;
212

213
  /*! Bit mask of the proxies this cell is registered with. */
214
215
  unsigned long long int sendto;

216
  /*! Pointer to this cell's packed representation. */
217
  struct pcell *pcell;
218
219

  /*! Size of the packed representation */
220
  int pcell_size;
221
222

  /*! MPI tag associated with this cell */
223
224
  int tag;

225
#endif
226

227
  /*! Minimum end of (integer) time step in this cell. */
228
  integertime_t ti_end_min;
229
230

  /*! Maximum end of (integer) time step in this cell. */
231
  integertime_t ti_end_max;
232

233
234
  /*! Maximum beginning of (integer) time step in this cell. */
  integertime_t ti_beg_max;
Matthieu Schaller's avatar
Matthieu Schaller committed
235

236
  /*! Last (integer) time the cell's particle was drifted forward in time. */
237
  integertime_t ti_old;
238

239
240
241
  /*! Last (integer) time the cell's multipole was drifted forward in time. */
  integertime_t ti_old_multipole;

242
243
244
245
246
247
248
249
250
251
252
253
  /*! Minimum dimension, i.e. smallest edge of this cell (min(width)). */
  float dmin;

  /*! Maximum particle movement in this cell since last construction. */
  float dx_max;

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

  /*! Nr of #gpart in this cell. */
  int gcount;

254
255
256
  /*! Nr of #spart in this cell. */
  int scount;

257
258
259
260
261
262
263
264
265
266
267
268
  /*! The size of the sort array */
  int sortsize;

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

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

  /*! Spin lock for various uses (#gpart case). */
  swift_lock_type glock;

269
270
271
  /*! Spin lock for various uses (#multipole case). */
  swift_lock_type mlock;

272
273
274
  /*! Spin lock for various uses (#spart case). */
  swift_lock_type slock;

275
276
277
278
279
280
281
282
283
  /*! ID of the previous owner, e.g. runner. */
  int owner;

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

  /*! Number of #gpart updated in this cell. */
  int g_updated;

284
285
286
  /*! Number of #spart updated in this cell. */
  int s_updated;

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

290
291
292
293
294
295
  /*! Is the #part data of this cell being used in a sub-cell? */
  int hold;

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

296
297
298
  /*! Is the #multipole data of this cell being used in a sub-cell? */
  int mhold;

299
300
301
  /*! Is the #spart data of this cell being used in a sub-cell? */
  int shold;

302
303
304
305
306
307
308
309
310
311
312
313
  /*! 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;

314
315
316
317
318
319
320
321
#ifdef SWIFT_DEBUG_CHECKS
  /*! 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

322
} SWIFT_STRUCT_ALIGN;
323

324
325
326
327
/* Convert cell location to ID. */
#define cell_getid(cdim, i, j, k) \
  ((int)(k) + (cdim)[2] * ((int)(j) + (cdim)[1] * (int)(i)))

328
/* Function prototypes. */
329
330
void cell_split(struct cell *c, ptrdiff_t parts_offset, ptrdiff_t sparts_offset,
                struct cell_buff *buff, struct cell_buff *sbuff,
331
                struct cell_buff *gbuff);
332
void cell_sanitize(struct cell *c);
333
334
335
336
int cell_locktree(struct cell *c);
void cell_unlocktree(struct cell *c);
int cell_glocktree(struct cell *c);
void cell_gunlocktree(struct cell *c);
337
338
int cell_mlocktree(struct cell *c);
void cell_munlocktree(struct cell *c);
339
340
int cell_slocktree(struct cell *c);
void cell_sunlocktree(struct cell *c);
341
342
int cell_pack(struct cell *c, struct pcell *pc);
int cell_unpack(struct pcell *pc, struct cell *c, struct space *s);
343
344
int cell_pack_ti_ends(struct cell *c, integertime_t *ti_ends);
int cell_unpack_ti_ends(struct cell *c, integertime_t *ti_ends);
345
int cell_getsize(struct cell *c);
346
347
int cell_link_parts(struct cell *c, struct part *parts);
int cell_link_gparts(struct cell *c, struct gpart *gparts);
348
int cell_link_sparts(struct cell *c, struct spart *sparts);
349
void cell_convert_hydro(struct cell *c, void *data);
350
void cell_clean_links(struct cell *c, void *data);
351
352
int cell_are_neighbours(const struct cell *restrict ci,
                        const struct cell *restrict cj);
353
void cell_check_multipole(struct cell *c, void *data);
354
void cell_clean(struct cell *c);
355
void cell_check_drift_point(struct cell *c, void *data);
356
void cell_reset_task_counters(struct cell *c);
357
int cell_is_drift_needed(struct cell *c, const struct engine *e);
358
int cell_unskip_tasks(struct cell *c, struct scheduler *s);
359
void cell_set_super(struct cell *c, struct cell *super);
360
void cell_drift_particles(struct cell *c, const struct engine *e);
361
void cell_drift_multipole(struct cell *c, const struct engine *e);
362
void cell_drift_all_multipoles(struct cell *c, const struct engine *e);
363
void cell_check_timesteps(struct cell *c);
364
365

#endif /* SWIFT_CELL_H */