cell.h 4.75 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
8
 * 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.
9
 *
10
11
12
13
 * 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.
14
 *
15
16
 * 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/>.
17
 *
18
 ******************************************************************************/
19
20
#ifndef SWIFT_CELL_H
#define SWIFT_CELL_H
21

22
/* Includes. */
Pedro Gonnet's avatar
Pedro Gonnet committed
23
#include "lock.h"
24
#include "multipole.h"
25
#include "part.h"
26
27
28

/* Forward declaration of space, needed for cell_unpack. */
struct space;
29

30
/* Some constants. */
31
#define cell_sid_dt 13
32
33
34
35
36
37

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

39
40
41
/* Global variables. */
extern int cell_next_tag;

42
43
44
/* Packed cell. */
struct pcell {

45
  /* Stats on this cell's particles. */
46
  double h_max, t_end_min, t_end_max;
47
48
49

  /* Number of particles in this cell. */
  int count;
Pedro Gonnet's avatar
Pedro Gonnet committed
50

51
52
  /* tag used for MPI communication. */
  int tag;
53

54
55
56
  /* Relative indices of the cell's progeny. */
  int progeny[8];
};
57

58
59
60
/* Structure to store the data of a single cell. */
struct cell {

61
62
63
64
65
66
67
68
69
  /* The cell location on the grid. */
  double loc[3];

  /* The cell dimensions. */
  double h[3];

  /* Max radii in this cell. */
  double h_max;

70
71
  /* Minimum and maximum end of time step in this cell. */
  double t_end_min, t_end_max;
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

  /* Minimum dimension, i.e. smallest edge of this cell. */
  float dmin;

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

  /* Maximum particle movement in this cell. */
  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;
109

110
111
112
113
114
115
116
117
118
  /* 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;

  /* The ghost task to link density to interactions. */
Matthieu Schaller's avatar
Matthieu Schaller committed
119
  struct task *ghost, *init, *drift, *kick;
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

  /* Task receiving data. */
  struct task *recv_xv, *recv_rho;

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

  /* 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. */
  lock_type lock, glock;

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

  /* Momentum of particles in cell. */
  float mom[3], ang[3];

  /* Potential and kinetic energy of particles in this cell. */
  double epot, ekin;

  /* Number of particles updated in this cell. */
  int updated;

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

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

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

  /* This cell's multipole. */
  struct multipole multipole;

} __attribute__((aligned(64)));
166
167

/* Function prototypes. */
168
169
170
171
172
173
174
175
176
void cell_split(struct cell *c);
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);
int cell_getsize(struct cell *c);
int cell_link(struct cell *c, struct part *parts);
177
void cell_init_parts(struct cell *c, void *data);
178
179

#endif /* SWIFT_CELL_H */