cell.h 7.76 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 space;
41
struct scheduler;
42

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

49
#define cell_align 128
50

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

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

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

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

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

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

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

} SWIFT_STRUCT_ALIGN;
81

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

149
150
  /*! The kick task */
  struct task *kick;
151

152
153
  /*! Task constructing the multipole from the particles */
  struct task *grav_up;
Tom Theuns's avatar
Tom Theuns committed
154

155
156
  /*! Task propagating the multipole to the particles */
  struct task *grav_down;
157

158
159
  /*! Task for cooling */
  struct task *cooling;
160

161
162
  /*! Task for source terms */
  struct task *sourceterms;
163

164
#ifdef WITH_MPI
165

166
167
  /* Task receiving data (positions). */
  struct task *recv_xv;
168

169
170
  /* Task receiving data (density). */
  struct task *recv_rho;
171

172
173
  /* Task receiving data (gradient). */
  struct task *recv_gradient;
174

175
176
  /* Task receiving data (time-step). */
  struct task *recv_ti;
177

178
179
  /* Linked list for sending data (positions). */
  struct link *send_xv;
180

181
182
  /* Linked list for sending data (density). */
  struct link *send_rho;
183

184
185
186
187
188
  /* Linked list for sending data (gradient). */
  struct link *send_gradient;

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

190
  /*! Bit mask of the proxies this cell is registered with. */
191
192
  unsigned long long int sendto;

193
  /*! Pointer to this cell's packed representation. */
194
  struct pcell *pcell;
195
196

  /*! Size of the packed representation */
197
  int pcell_size;
198
199

  /*! MPI tag associated with this cell */
200
201
  int tag;

202
#endif
203

204
205
206
207
208
209
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
256
257
258
259
260
261
262
263
264
265
266
  /*! 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;

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

  /*! Is the #part data of this cell being used in a sub-cell? */
  char hold;

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

267
} SWIFT_STRUCT_ALIGN;
268

269
270
271
272
/* Convert cell location to ID. */
#define cell_getid(cdim, i, j, k) \
  ((int)(k) + (cdim)[2] * ((int)(j) + (cdim)[1] * (int)(i)))

273
/* Function prototypes. */
274
void cell_split(struct cell *c, ptrdiff_t parts_offset);
275
void cell_sanitize(struct cell *c);
276
277
278
279
280
281
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);
282
283
int cell_pack_ti_ends(struct cell *c, int *ti_ends);
int cell_unpack_ti_ends(struct cell *c, int *ti_ends);
284
int cell_getsize(struct cell *c);
285
286
int cell_link_parts(struct cell *c, struct part *parts);
int cell_link_gparts(struct cell *c, struct gpart *gparts);
287
void cell_convert_hydro(struct cell *c, void *data);
288
void cell_clean_links(struct cell *c, void *data);
289
290
int cell_are_neighbours(const struct cell *restrict ci,
                        const struct cell *restrict cj);
291
void cell_check_multipole(struct cell *c, void *data);
292
void cell_clean(struct cell *c);
293
int cell_is_drift_needed(struct cell *c, int ti_current);
294
int cell_unskip_tasks(struct cell *c, struct scheduler *s);
295
void cell_set_super(struct cell *c, struct cell *super);
296
297

#endif /* SWIFT_CELL_H */