cell.h 8.04 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
/* Struct to temporarily buffer the particle locations and bin id. */
struct cell_buff {
  double x[3];
  int ind;
59
} SWIFT_STRUCT_ALIGN;
60

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

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

74
  /* Stats on this cell's particles. */
75
76
  double h_max;
  int ti_end_min, ti_end_max;
77
78

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

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

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

} SWIFT_STRUCT_ALIGN;
88

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

96
97
98
99
  /*! This cell's multipole. */
  struct multipole multipole;

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

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

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

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

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

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

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

120
  /*! Pointer for the sorted indices. */
121
  struct entry *sort;
122

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

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

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

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

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

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

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

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

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

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

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

156
157
  /*! The kick task */
  struct task *kick;
158

159
160
  /*! Task constructing the multipole from the particles */
  struct task *grav_up;
Tom Theuns's avatar
Tom Theuns committed
161

162
163
  /*! Task propagating the multipole to the particles */
  struct task *grav_down;
164

165
166
  /*! Task for cooling */
  struct task *cooling;
167

168
169
  /*! Task for source terms */
  struct task *sourceterms;
170

171
#ifdef WITH_MPI
172

173
174
  /* Task receiving data (positions). */
  struct task *recv_xv;
175

176
177
  /* Task receiving data (density). */
  struct task *recv_rho;
178

179
180
  /* Task receiving data (gradient). */
  struct task *recv_gradient;
181

182
183
  /* Task receiving data (time-step). */
  struct task *recv_ti;
184

185
186
  /* Linked list for sending data (positions). */
  struct link *send_xv;
187

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

191
192
193
194
195
  /* Linked list for sending data (gradient). */
  struct link *send_gradient;

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

197
  /*! Bit mask of the proxies this cell is registered with. */
198
199
  unsigned long long int sendto;

200
  /*! Pointer to this cell's packed representation. */
201
  struct pcell *pcell;
202
203

  /*! Size of the packed representation */
204
  int pcell_size;
205
206

  /*! MPI tag associated with this cell */
207
208
  int tag;

209
#endif
210

211
212
213
214
215
216
217
218
219
220
221
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
  /*! Minimum end of (integer) time step in this cell. */
  int ti_end_min;

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

  /*! Last (integer) time the cell's content was drifted forward in time. */
  int ti_old;

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

256
257
258
259
260
261
  /*! 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;

262
263
264
265
266
267
268
269
270
271
272
273
  /*! 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;

274
} SWIFT_STRUCT_ALIGN;
275

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

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

#endif /* SWIFT_CELL_H */