1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
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
109
110
111
112
113
114
115
116
117
118
119
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
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
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
|
#include <assert.h>
#include <stdlib.h>
#include "cctk.h"
#include "cctk_Parameters.h"
#include "dh.hh"
#include "gf.hh"
#include "carpet.hh"
extern "C" {
static const char* rcsid = "$Header:$";
CCTK_FILEVERSION(Carpet_Carpet_Storage_cc);
}
namespace Carpet {
using namespace std;
int EnableGroupStorage (const cGH* cgh, const char* groupname)
{
DECLARE_CCTK_PARAMETERS;
Checkpoint ("EnableGroupStorage \"%s\"", groupname);
// TODO: Enabling storage for one refinement level has to enable
// it for all other refinement levels as well. Disabling must
// wait until all refinement levels have been disabled.
const int group = CCTK_GroupIndex(groupname);
assert (group>=0 && group<CCTK_NumGroups());
if (CCTK_NumVarsInGroupI(group)==0) return 0;
const int grouptype = CCTK_GroupTypeI(group);
// No storage change in local mode
if (grouptype == CCTK_GF) {
assert ((map == -1 || maps == 1)
&& (component == -1
|| vhh.at(0)->local_components(reflevel) == 1));
}
if (CCTK_QueryGroupStorageI(cgh, group)) {
// storage was enabled previously
const int n0 = CCTK_FirstVarIndexI(group);
assert (n0>=0);
const int num_tl = CCTK_NumTimeLevelsFromVarI(n0);
assert (num_tl>0);
return num_tl;
}
// There is a difference between the Cactus time levels and the
// Carpet time levels. If there are n time levels, then the
// Cactus time levels are numbered 0 ... n-1, with the current
// time level being 0. In Carpet, the time levels are numbered
// -(n-1) ... 0, where the current time level is also 0.
const int n0 = CCTK_FirstVarIndexI(group);
assert (n0>=0);
const int num_tl = CCTK_NumTimeLevelsFromVarI(n0);
assert (num_tl>0);
const int tmin = 1 - num_tl;
const int tmax = 0;
if (grouptype == CCTK_GF) {
if (max_refinement_levels > 1) {
if (groupdata.at(group).transport_operator != op_none) {
if (num_tl <= prolongation_order_time) {
CCTK_VWarn (0, __LINE__, __FILE__, CCTK_THORNSTRING,
"There are not enough time levels for the desired temporal prolongation order in the grid function group \"%s\". With Carpet::prolongation_order_time=%d, you need at least %d time levels.",
CCTK_GroupName(group),
prolongation_order_time, prolongation_order_time+1);
}
}
}
}
cGroup gp;
const int ierr = CCTK_GroupData (group, &gp);
assert (!ierr);
const int vectorlength = gp.vectorgroup ? gp.vectorlength : 1;
assert (arrdata.at(group).at(0).data.size()==0
|| arrdata.at(group).at(0).data.at(0) == 0);
for (int m=0; m<(int)arrdata.at(group).size(); ++m) {
for (int var=0; var<CCTK_NumVarsInGroupI(group); ++var) {
const int vectorindex = gp.vectorgroup ? var % vectorlength : 0;
ggf<dim>* vectorleader
= (gp.vectorgroup && vectorindex>0
? arrdata.at(group).at(m).data.at(var - vectorindex)
: NULL);
const int n = n0 + var;
switch (CCTK_VarTypeI(n)) {
#define TYPECASE(N,T) \
case N: \
arrdata.at(group).at(m).data.at(var) = new gf<T,dim> \
(n, groupdata.at(group).transport_operator, \
*arrdata.at(group).at(m).tt, *arrdata.at(group).at(m).dd, \
tmin, tmax, prolongation_order_time, \
vectorlength, vectorindex, (gf<T,dim>*)vectorleader); \
break;
#include "typecase"
#undef TYPECASE
default:
UnsupportedVarType(n);
} // switch
if (grouptype != CCTK_GF) {
for (int tl=0; tl<num_tl; ++tl) {
assert (m == 0);
int const c = CCTK_MyProc(cgh);
cgh->data[n][tl] = ((*arrdata.at(group).at(m).data.at(var))
(-tl, 0, c, 0)->storage());
}
}
} // for
} // for
// PoisonGroup (cgh, group, alltimes);
// storage was not enabled previously
return 0;
}
int DisableGroupStorage (const cGH* cgh, const char* groupname)
{
Checkpoint ("DisableGroupStorage \"%s\"", groupname);
const int group = CCTK_GroupIndex(groupname);
assert (group>=0 && group<CCTK_NumGroups());
// No storage change in local mode
assert (! (component!=-1 && CCTK_GroupTypeI(group)==CCTK_GF));
if (! CCTK_QueryGroupStorageI(cgh, group)) {
// storage was disabled previously
return 0;
}
// TODO
CCTK_WARN (2, "Cannot disable storage -- storage management is not yet consistent for FMR");
return 1;
const int n0 = CCTK_FirstVarIndexI(group);
assert (n0>=0);
const int num_tl = CCTK_NumTimeLevelsFromVarI(n0);
assert (num_tl>0);
for (int m=0; m<(int)arrdata.at(group).size(); ++m) {
for (int var=0; var<CCTK_NumVarsInGroupI(group); ++var) {
const int n = n0 + var;
switch (CCTK_VarTypeI(n)) {
#define TYPECASE(N,T) \
case N: \
assert (arrdata.at(group).at(m).data.at(var)); \
delete (gf<T,dim>*)arrdata.at(group).at(m).data.at(var); \
arrdata.at(group).at(m).data.at(var) = NULL; \
break;
#include "typecase"
#undef TYPECASE
default:
UnsupportedVarType(n);
} // switch
arrdata.at(group).at(m).data.at(var) = NULL;
if (CCTK_GroupTypeI(group) != CCTK_GF) {
for (int tl=0; tl<num_tl; ++tl) {
cgh->data[n][tl] = NULL;
}
}
} // for
} // for
// storage was enabled previously
return 1;
}
int QueryGroupStorageB (const cGH* cgh, int group, const char* groupname)
{
if (groupname) {
group = CCTK_GroupIndex(groupname);
}
assert (group>=0 && group<CCTK_NumGroups());
if (CCTK_NumVarsInGroupI(group)==0) return 0;
const int n = CCTK_FirstVarIndexI(group);
assert (n>=0 && n<CCTK_NumVars());
const int var = 0;
return arrdata.at(group).at(0).data.at(var) != NULL;
}
const int* ArrayGroupSizeB (const cGH* cgh, int dir, int group,
const char* groupname)
{
static const int zero = 0;
static const int error = 0;
if (groupname) {
group = CCTK_GroupIndex(groupname);
}
assert (group>=0 && group<CCTK_NumGroups());
if (mglevel == -1) {
return &error; // meta mode
}
const int gptype = CCTK_GroupTypeI (group);
if (gptype == CCTK_GF && map == -1) {
return &error; // global or level mode for a GF
}
const int gpdim = groupdata.at(group).info.dim;
assert (dir>=0 && dir<gpdim);
if (CCTK_QueryGroupStorageI(cgh, group)) {
return &groupdata.at(group).info.lsh[dir];
} else {
// no storage
return &zero;
}
}
int GroupDynamicData (const cGH* cgh, int group, cGroupDynamicData* data)
{
assert (group>=0 && group<CCTK_NumGroups());
*data = groupdata.at(group).info;
return 0;
}
} // namespace Carpet
|
