cell.h 6.35 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. */
Pedro Gonnet's avatar
Pedro Gonnet committed
33
#include "lock.h"
34
#include "multipole.h"
35
36
#include "part.h"
#include "task.h"
37

38
/* Avoid cyclic inclusions */
39
struct space;
40

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

47
48
49
/* Global variables. */
extern int cell_next_tag;

50
51
52
53
54
55
56
57
58
59
/* 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;
};

60
61
62
/* Packed cell. */
struct pcell {

63
  /* Stats on this cell's particles. */
64
65
  double h_max;
  int ti_end_min, ti_end_max;
66
67

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

70
71
  /* tag used for MPI communication. */
  int tag;
72

73
74
75
  /* Relative indices of the cell's progeny. */
  int progeny[8];
};
76

77
78
79
/* Structure to store the data of a single cell. */
struct cell {

80
81
82
83
  /* The cell location on the grid. */
  double loc[3];

  /* The cell dimensions. */
84
  double width[3];
85

86
  /* Max smoothing length in this cell. */
87
88
  double h_max;

89
  /* Minimum and maximum end of time step in this cell. */
90
  int ti_end_min, ti_end_max;
91

92
93
94
  /* Last time the cell's content was drifted forward in time. */
  int ti_old;

95
96
97
98
99
100
  /* Minimum dimension, i.e. smallest edge of this cell. */
  float dmin;

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

101
  /* Maximum particle movement in this cell since last construction. */
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
  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. */
  struct entry *sort, *gsort;
  unsigned int sorted, gsorted;

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

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

  /* Super cell, i.e. the highest-level supercell that has interactions. */
  struct cell *super;
131

132
133
134
135
136
  /* The task computing this cell's sorts. */
  struct task *sorts, *gsorts;
  int sortsize, gsortsize;

  /* The tasks computing this cell's density. */
137
138
  struct link *density, *gradient, *force, *grav;
  int nr_density, nr_gradient, nr_force, nr_grav;
139

Matthieu Schaller's avatar
Matthieu Schaller committed
140
  /* The hierarchical tasks. */
141
  struct task *extra_ghost, *ghost, *init, *kick;
142

143
#ifdef WITH_MPI
144
145
  
/* Task receiving data. */
146
  struct task *recv_xv, *recv_rho, *recv_gradient, *recv_ti;
147

148
  /* Task send data. */
149
  struct link *send_xv, *send_rho, *send_gradient, *send_ti;
150

151
#endif
152
153
154
155

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

156
157
158
  /* Task for external gravity */
  struct task *grav_external;

159
160
161
162
163
164
165
  /* 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. */
166
  swift_lock_type lock, glock;
167
168
169
170
171

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

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

174
  /* Mass, potential, internal  and kinetic energy of particles in this cell. */
175
  double mass, e_pot, e_int, e_kin, entropy;
176
177

  /* Number of particles updated in this cell. */
178
  int updated, g_updated;
179
180
181
182

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

183
184
185
  /* This cell's multipole. */
  struct multipole multipole;

186
187
188
  /* ID of the node this cell lives on. */
  int nodeID;

189
190
#ifdef WITH_MPI

191
192
193
194
195
196
197
198
  /* 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;

199
#endif
200
201

} __attribute__((aligned(64)));
202

203
204
205
206
/* Convert cell location to ID. */
#define cell_getid(cdim, i, j, k) \
  ((int)(k) + (cdim)[2] * ((int)(j) + (cdim)[1] * (int)(i)))

207
/* Function prototypes. */
208
void cell_split(struct cell *c, ptrdiff_t parts_offset);
209
210
211
212
213
214
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);
215
216
int cell_pack_ti_ends(struct cell *c, int *ti_ends);
int cell_unpack_ti_ends(struct cell *c, int *ti_ends);
217
int cell_getsize(struct cell *c);
218
219
int cell_link_parts(struct cell *c, struct part *parts);
int cell_link_gparts(struct cell *c, struct gpart *gparts);
220
void cell_init_parts(struct cell *c, void *data);
221
void cell_init_gparts(struct cell *c, void *data);
222
void cell_convert_hydro(struct cell *c, void *data);
223
void cell_clean_links(struct cell *c, void *data);
224
225
int cell_are_neighbours(const struct cell *restrict ci,
                        const struct cell *restrict cj);
226
void cell_check_multipole(struct cell *c, void *data);
227
void cell_clean(struct cell *c);
228
int cell_is_drift_needed(struct cell *c, int ti_current);
229
230

#endif /* SWIFT_CELL_H */