cell.h 8.16 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
60
61
62
63
64
65
/* 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;
};

66
67
68
/* Packed cell. */
struct pcell {

69
  /* Stats on this cell's particles. */
70
  double h_max;
71
  integertime_t ti_end_min, ti_end_max, ti_old;
72
73

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

76
77
  /* tag used for MPI communication. */
  int tag;
78

79
80
  /* Relative indices of the cell's progeny. */
  int progeny[8];
81
82

} SWIFT_STRUCT_ALIGN;
83

84
85
86
87
88
/**
 * @brief Cell within the tree structure.
 *
 * Contains particles, links to tasks, a multipole object and counters.
 */
89
90
struct cell {

91
92
93
94
  /*! This cell's multipole. */
  struct multipole multipole;

  /*! The cell location on the grid. */
95
96
  double loc[3];

97
  /*! The cell dimensions. */
98
  double width[3];
99

100
  /*! Max smoothing length in this cell. */
101
102
  double h_max;

103
104
  /*! Linking pointer for "memory management". */
  struct cell *next;
105

106
  /*! Pointer to the #part data. */
107
108
  struct part *parts;

109
  /*! Pointer to the #xpart data. */
110
111
  struct xpart *xparts;

112
  /*! Pointer to the #gpart data. */
113
114
  struct gpart *gparts;

115
  /*! Pointer for the sorted indices. */
116
  struct entry *sort;
117

118
  /*! Pointers to the next level of cells. */
119
120
  struct cell *progeny[8];

121
  /*! Parent cell. */
122
123
  struct cell *parent;

124
  /*! Super cell, i.e. the highest-level parent cell that has pair/self tasks */
125
  struct cell *super;
126

127
  /*! The task computing this cell's sorts. */
128
  struct task *sorts;
129

130
131
  /*! Linked list of the tasks computing this cell's hydro density. */
  struct link *density;
132

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

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

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

142
143
  /*! The initialistation task */
  struct task *init;
144

145
146
  /*! The ghost task */
  struct task *ghost;
147

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

151
152
153
  /*! The drift task */
  struct task *drift;

154
155
156
157
158
  /*! The first kick task */
  struct task *kick1;

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

160
161
162
  /*! The task to compute time-steps */
  struct task *timestep;

163
164
  /*! Task constructing the multipole from the particles */
  struct task *grav_up;
Tom Theuns's avatar
Tom Theuns committed
165

166
167
  /*! Task propagating the multipole to the particles */
  struct task *grav_down;
168

169
170
  /*! Task for cooling */
  struct task *cooling;
171

172
173
  /*! Task for source terms */
  struct task *sourceterms;
174

175
#ifdef WITH_MPI
176

177
178
  /* Task receiving data (positions). */
  struct task *recv_xv;
179

180
181
  /* Task receiving data (density). */
  struct task *recv_rho;
182

183
184
  /* Task receiving data (gradient). */
  struct task *recv_gradient;
185

186
187
  /* Task receiving data (time-step). */
  struct task *recv_ti;
188

189
190
  /* Linked list for sending data (positions). */
  struct link *send_xv;
191

192
193
  /* Linked list for sending data (density). */
  struct link *send_rho;
194

195
196
197
198
199
  /* Linked list for sending data (gradient). */
  struct link *send_gradient;

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

201
  /*! Bit mask of the proxies this cell is registered with. */
202
203
  unsigned long long int sendto;

204
  /*! Pointer to this cell's packed representation. */
205
  struct pcell *pcell;
206
207

  /*! Size of the packed representation */
208
  int pcell_size;
209
210

  /*! MPI tag associated with this cell */
211
212
  int tag;

213
#endif
214

215
  /*! Minimum end of (integer) time step in this cell. */
216
  integertime_t ti_end_min;
217
218

  /*! Maximum end of (integer) time step in this cell. */
219
  integertime_t ti_end_max;
220
221

  /*! Last (integer) time the cell's content was drifted forward in time. */
222
  integertime_t ti_old;
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259

  /*! 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;

  /*! 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;

  /*! 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;

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

260
261
262
263
264
265
  /*! 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;

266
267
268
269
270
271
272
273
274
275
276
277
  /*! 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;

278
} SWIFT_STRUCT_ALIGN;
279

280
281
282
283
/* Convert cell location to ID. */
#define cell_getid(cdim, i, j, k) \
  ((int)(k) + (cdim)[2] * ((int)(j) + (cdim)[1] * (int)(i)))

284
/* Function prototypes. */
285
void cell_split(struct cell *c, ptrdiff_t parts_offset, int *buff);
286
void cell_sanitize(struct cell *c);
287
288
289
290
291
292
int cell_locktree(struct cell *c);
void cell_unlocktree(struct cell *c);
int cell_glocktree(struct cell *c);
void cell_gunlocktree(struct cell *c);
int cell_pack(struct cell *c, struct pcell *pc);
int cell_unpack(struct pcell *pc, struct cell *c, struct space *s);
293
294
int cell_pack_ti_ends(struct cell *c, integertime_t *ti_ends);
int cell_unpack_ti_ends(struct cell *c, integertime_t *ti_ends);
295
int cell_getsize(struct cell *c);
296
297
int cell_link_parts(struct cell *c, struct part *parts);
int cell_link_gparts(struct cell *c, struct gpart *gparts);
298
void cell_convert_hydro(struct cell *c, void *data);
299
void cell_clean_links(struct cell *c, void *data);
300
301
int cell_are_neighbours(const struct cell *restrict ci,
                        const struct cell *restrict cj);
302
void cell_check_multipole(struct cell *c, void *data);
303
void cell_clean(struct cell *c);
304
void cell_check_drift_point(struct cell *c, void *data);
305
int cell_is_drift_needed(struct cell *c, const struct engine *e);
306
int cell_unskip_tasks(struct cell *c, struct scheduler *s);
307
void cell_set_super(struct cell *c, struct cell *super);
308
void cell_drift(struct cell *c, const struct engine *e);
Matthieu Schaller's avatar
Matthieu Schaller committed
309

310
#endif /* SWIFT_CELL_H */