cell.h 6.18 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
137
138
139
  /* The task computing this cell's sorts. */
  struct task *sorts, *gsorts;
  int sortsize, gsortsize;

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

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

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

147
  /* Task send data. */
148
  struct link *send_xv, *send_rho, *send_ti;
149
#endif
150
151
152
153

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

154
155
156
  /* Task for external gravity */
  struct task *grav_external;

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

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

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

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

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

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

181
182
183
  /* This cell's multipole. */
  struct multipole multipole;

184
185
186
  /* ID of the node this cell lives on. */
  int nodeID;

187
188
#ifdef WITH_MPI

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

197
#endif
198
199

} __attribute__((aligned(64)));
200

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

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

#endif /* SWIFT_CELL_H */