cell.h 6.44 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
/* Structure to store the data of a single cell. */
struct cell {

85
86
87
88
  /* The cell location on the grid. */
  double loc[3];

  /* The cell dimensions. */
89
  double width[3];
90

91
  /* Max smoothing length in this cell. */
92
93
  double h_max;

94
  /* Minimum and maximum end of time step in this cell. */
95
  int ti_end_min, ti_end_max;
96

97
98
99
  /* Last time the cell's content was drifted forward in time. */
  int ti_old;

100
101
102
103
104
105
  /* Minimum dimension, i.e. smallest edge of this cell. */
  float dmin;

  /* Maximum slack allowed for particle movement. */
  float slack;

106
  /* Maximum particle movement in this cell since last construction. */
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
  float dx_max;

  /* The depth of this cell in the tree. */
  int depth, split, maxdepth;

  /* Nr of parts. */
  int count, gcount;

  /* Pointers to the particle data. */
  struct part *parts;

  /* Pointers to the extra particle data. */
  struct xpart *xparts;

  /* Pointers to the gravity particle data. */
  struct gpart *gparts;

  /* Pointers for the sorted indices. */
125
126
  struct entry *sort;
  unsigned int sorted;
127
128
129
130
131
132
133

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

  /* Parent cell. */
  struct cell *parent;

134
  /* Super cell, i.e. the highest-level supercell that has pair/self tasks */
135
  struct cell *super;
136

137
  /* The task computing this cell's sorts. */
138
139
  struct task *sorts;
  int sortsize;
140
141

  /* The tasks computing this cell's density. */
142
  struct link *density, *gradient, *force, *grav;
143

Matthieu Schaller's avatar
Matthieu Schaller committed
144
  /* The hierarchical tasks. */
145
  struct task *extra_ghost, *ghost, *init, *kick;
146

147
#ifdef WITH_MPI
148
149

  /* Task receiving data. */
150
  struct task *recv_xv, *recv_rho, *recv_gradient, *recv_ti;
151

152
  /* Task send data. */
153
  struct link *send_xv, *send_rho, *send_gradient, *send_ti;
154

155
#endif
156
157
158
159

  /* Tasks for gravity tree. */
  struct task *grav_up, *grav_down;

160
  /* Task for cooling */
Matthieu Schaller's avatar
Matthieu Schaller committed
161
  struct task *cooling;
162

Tom Theuns's avatar
Tom Theuns committed
163
164
165
  /* Task for source terms */
  struct task *sourceterms;

166
167
168
169
170
171
172
  /* Number of tasks that are associated with this cell. */
  int nr_tasks;

  /* Is the data of this cell being used in a sub-cell? */
  int hold, ghold;

  /* Spin lock for various uses. */
173
  swift_lock_type lock, glock;
174
175
176
177
178

  /* ID of the previous owner, e.g. runner. */
  int owner;

  /* Momentum of particles in cell. */
179
  double mom[3], ang_mom[3];
180

181
  /* Mass, potential, internal  and kinetic energy of particles in this cell. */
182
  double mass, e_pot, e_int, e_kin, e_rad, entropy;
183
184

  /* Number of particles updated in this cell. */
185
  int updated, g_updated;
186
187
188
189

  /* Linking pointer for "memory management". */
  struct cell *next;

190
191
192
  /* This cell's multipole. */
  struct multipole multipole;

193
194
195
  /* ID of the node this cell lives on. */
  int nodeID;

196
197
#ifdef WITH_MPI

198
199
200
201
202
203
204
205
  /* Bit mask of the proxies this cell is registered with. */
  unsigned long long int sendto;

  /* Pointer to this cell's packed representation. */
  struct pcell *pcell;
  int pcell_size;
  int tag;

206
#endif
207

208
} SWIFT_STRUCT_ALIGN;
209

210
211
212
213
/* Convert cell location to ID. */
#define cell_getid(cdim, i, j, k) \
  ((int)(k) + (cdim)[2] * ((int)(j) + (cdim)[1] * (int)(i)))

214
/* Function prototypes. */
215
void cell_split(struct cell *c, ptrdiff_t parts_offset);
216
void cell_sanitize(struct cell *c);
217
218
219
220
221
222
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);
223
224
int cell_pack_ti_ends(struct cell *c, int *ti_ends);
int cell_unpack_ti_ends(struct cell *c, int *ti_ends);
225
int cell_getsize(struct cell *c);
226
227
int cell_link_parts(struct cell *c, struct part *parts);
int cell_link_gparts(struct cell *c, struct gpart *gparts);
228
void cell_convert_hydro(struct cell *c, void *data);
229
void cell_clean_links(struct cell *c, void *data);
230
231
int cell_are_neighbours(const struct cell *restrict ci,
                        const struct cell *restrict cj);
232
void cell_check_multipole(struct cell *c, void *data);
233
void cell_clean(struct cell *c);
234
int cell_is_drift_needed(struct cell *c, int ti_current);
235
int cell_unskip_tasks(struct cell *c, struct scheduler *s);
236
void cell_set_super(struct cell *c, struct cell *super);
237
238

#endif /* SWIFT_CELL_H */