cell.h 8.5 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;
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
98
99
100
  /*! This cell's multipole. */
  struct multipole multipole;

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

103
  /*! The cell dimensions. */
104
  double width[3];
105

106
  /*! Max smoothing length in this cell. */
107
108
  double h_max;

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 for the sorted indices. */
122
  struct entry *sort;
123

124
  /*! Pointers to the next level of cells. */
125
126
  struct cell *progeny[8];

127
  /*! Parent cell. */
128
129
  struct cell *parent;

130
  /*! Super cell, i.e. the highest-level parent cell that has pair/self tasks */
131
  struct cell *super;
132

133
  /*! The task computing this cell's sorts. */
134
  struct task *sorts;
135

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

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

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

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

148
149
  /*! The initialistation task */
  struct task *init;
150

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

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

157
158
159
  /*! The drift task */
  struct task *drift;

160
161
162
163
164
  /*! The first kick task */
  struct task *kick1;

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

166
167
168
  /*! The task to compute time-steps */
  struct task *timestep;

169
170
  /*! Task constructing the multipole from the particles */
  struct task *grav_up;
Tom Theuns's avatar
Tom Theuns committed
171

172
173
  /*! Task propagating the multipole to the particles */
  struct task *grav_down;
174

175
176
  /*! Task for cooling */
  struct task *cooling;
177

178
179
  /*! Task for source terms */
  struct task *sourceterms;
180

181
#ifdef WITH_MPI
182

183
184
  /* Task receiving data (positions). */
  struct task *recv_xv;
185

186
187
  /* Task receiving data (density). */
  struct task *recv_rho;
188

189
190
  /* Task receiving data (gradient). */
  struct task *recv_gradient;
191

192
193
  /* Task receiving data (time-step). */
  struct task *recv_ti;
194

195
196
  /* Linked list for sending data (positions). */
  struct link *send_xv;
197

198
199
  /* Linked list for sending data (density). */
  struct link *send_rho;
200

201
202
203
204
205
  /* Linked list for sending data (gradient). */
  struct link *send_gradient;

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

207
  /*! Bit mask of the proxies this cell is registered with. */
208
209
  unsigned long long int sendto;

210
  /*! Pointer to this cell's packed representation. */
211
  struct pcell *pcell;
212
213

  /*! Size of the packed representation */
214
  int pcell_size;
215
216

  /*! MPI tag associated with this cell */
217
218
  int tag;

219
#endif
220

221
  /*! Minimum end of (integer) time step in this cell. */
222
  integertime_t ti_end_min;
223
224

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

227
228
229
  /*! Maximum beginning of (integer) time step in this cell. */
  integertime_t ti_beg_max;
  
230
  /*! Last (integer) time the cell's content was drifted forward in time. */
231
  integertime_t ti_old;
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
260
261
262
263
264
265
266
267
268

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

269
270
271
272
273
274
  /*! 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;

275
276
277
278
279
280
281
282
283
284
285
286
  /*! 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;

287
} SWIFT_STRUCT_ALIGN;
288

289
290
291
292
/* Convert cell location to ID. */
#define cell_getid(cdim, i, j, k) \
  ((int)(k) + (cdim)[2] * ((int)(j) + (cdim)[1] * (int)(i)))

293
/* Function prototypes. */
294
295
void cell_split(struct cell *c, ptrdiff_t parts_offset, struct cell_buff *buff,
                struct cell_buff *gbuff);
296
void cell_sanitize(struct cell *c);
297
298
299
300
301
302
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);
303
304
int cell_pack_ti_ends(struct cell *c, integertime_t *ti_ends);
int cell_unpack_ti_ends(struct cell *c, integertime_t *ti_ends);
305
int cell_getsize(struct cell *c);
306
307
int cell_link_parts(struct cell *c, struct part *parts);
int cell_link_gparts(struct cell *c, struct gpart *gparts);
308
void cell_convert_hydro(struct cell *c, void *data);
309
void cell_clean_links(struct cell *c, void *data);
310
311
int cell_are_neighbours(const struct cell *restrict ci,
                        const struct cell *restrict cj);
312
void cell_check_multipole(struct cell *c, void *data);
313
void cell_clean(struct cell *c);
314
void cell_check_drift_point(struct cell *c, void *data);
315
int cell_is_drift_needed(struct cell *c, const struct engine *e);
316
int cell_unskip_tasks(struct cell *c, struct scheduler *s);
317
void cell_set_super(struct cell *c, struct cell *super);
318
void cell_drift(struct cell *c, const struct engine *e);
319
void cell_check_timesteps(struct cell *c);
Matthieu Schaller's avatar
Matthieu Schaller committed
320

321
#endif /* SWIFT_CELL_H */