cell.h 8.12 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

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

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

50
#define cell_align 128
51

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

55
56
57
58
59
60
61
62
63
64
/* 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;
};

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

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

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

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

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

} SWIFT_STRUCT_ALIGN;
82

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

174
#ifdef WITH_MPI
175

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

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

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

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

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

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

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

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

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

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

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

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

212
#endif
213

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

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

  /*! Last (integer) time the cell's content was drifted forward in time. */
221
  integertime_t ti_old;
222
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

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

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

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

277
} SWIFT_STRUCT_ALIGN;
278

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

283
/* Function prototypes. */
284
void cell_split(struct cell *c, ptrdiff_t parts_offset, int *buff);
285
void cell_sanitize(struct cell *c);
286
287
288
289
290
291
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);
292
293
int cell_pack_ti_ends(struct cell *c, int *ti_ends);
int cell_unpack_ti_ends(struct cell *c, int *ti_ends);
294
int cell_getsize(struct cell *c);
295
296
int cell_link_parts(struct cell *c, struct part *parts);
int cell_link_gparts(struct cell *c, struct gpart *gparts);
297
void cell_convert_hydro(struct cell *c, void *data);
298
void cell_clean_links(struct cell *c, void *data);
299
300
int cell_are_neighbours(const struct cell *restrict ci,
                        const struct cell *restrict cj);
301
void cell_check_multipole(struct cell *c, void *data);
302
void cell_clean(struct cell *c);
303
void cell_check_drift_point(struct cell *c, void *data);
304
int cell_is_drift_needed(struct cell *c, const struct engine *e);
305
int cell_unskip_tasks(struct cell *c, struct scheduler *s);
306
void cell_set_super(struct cell *c, struct cell *super);
307
void cell_drift(struct cell *c, const struct engine *e);
Matthieu Schaller's avatar
Matthieu Schaller committed
308

309
#endif /* SWIFT_CELL_H */