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
|
// patch_system.hh -- describes the (an) entire system of interlinked patches
// $Id$
//
// patch_system - describes a system of interlinked patches
//
//
// prerequisites:
// <stdio.h>
// <assert.h>
// <math.h>
// "jt/util.hh"
// "jt/array.hh"
// "jt/linear_map.hh"
// fp.hh
// coords.hh
// grid.hh
// patch.hh
// patch_edge.hh
// ghost_zone.hh
// patch_interp.hh
//
//******************************************************************************
//
// a patch_system object describes a system of interlinked patches.
//
class patch_system
{
//
// ***** static data & functions describing patch systems *****
//
public:
// what patch-system type are supported?
enum patch_system_type {
full_sphere_patch_system,
plus_z_hemisphere_patch_system,
plus_xy_quadrant_patch_system,
plus_xz_quadrant_patch_system,
plus_xyz_octant_patch_system
};
// maximum number of patches in any patch-system type
static const int max_N_patches = 6;
// decode patch system type into N_patches
static
int N_patches_of_type(enum patch_system_type type_in);
// patch system type <--> human-readable character-string name
static
const char* name_of_type(enum patch_system_type type_in);
static
enum patch_system_type type_of_name(const char* name_in);
//
// ***** coordinates *****
//
public:
// global (x,y,z) --> local (x,y,z)
fp local_x_of_global_x(fp global_x) const
{ return global_coords_.local_x_of_global_x(global_x); }
fp local_y_of_global_y(fp global_y) const
{ return global_coords_.local_y_of_global_y(global_y); }
fp local_z_of_global_z(fp global_z) const
{ return global_coords_.local_z_of_global_z(global_z); }
// local (x,y,z) --> global (x,y,z)
fp global_x_of_local_x(fp local_x) const
{ return global_coords_.global_x_of_local_x(local_x); }
fp global_y_of_local_y(fp local_y) const
{ return global_coords_.global_y_of_local_y(local_y); }
fp global_z_of_local_z(fp local_z) const
{ return global_coords_.global_z_of_local_z(local_z); }
// ... get global (x,y,z) coordinates of local origin point
fp origin_x() const { return global_coords_.origin_x(); }
fp origin_y() const { return global_coords_.origin_y(); }
fp origin_z() const { return global_coords_.origin_z(); }
//
// ***** meta-info about the entire patch system *****
//
public:
// patch-system type
enum patch_system_type type() const { return type_; }
// total number of patches
int N_patches() const { return N_patches_; }
// get patches by patch number
patch &ith_patch(int pn) const
{ return * all_patches_[pn]; }
// find a patch by name, return patch number; error_exit() if not found
int patch_number_of_name(const char* name) const;
// total number of grid points
int N_grid_points() const { return N_grid_points_; }
int ghosted_N_grid_points() const { return ghosted_N_grid_points_; }
//
// ***** meta-info about gridfns *****
//
public:
int min_gfn() const { return ith_patch(0).min_gfn(); }
int max_gfn() const { return ith_patch(0).max_gfn(); }
int N_gridfns() const { return ith_patch(0).N_gridfns(); }
int ghosted_min_gfn() const { return ith_patch(0).ghosted_min_gfn(); }
int ghosted_max_gfn() const { return ith_patch(0).ghosted_max_gfn(); }
int ghosted_N_gridfns() const
{ return ith_patch(0).ghosted_N_gridfns(); }
//
// ***** misc stuff *****
//
public:
// "synchronize" all ghost zones of all patches,
// i.e. update the ghost-zone values of the specified gridfns
// via the appropriate sequence of symmetry operations
// and interpatch interpolations
void synchronize_ghost_zones(int ghosted_min_gfn_to_sync,
int ghosted_max_gfn_to_sync);
// print a gridfn (via C stdio) in ASCII format
// output is assumed to already be open
// output format is suitable for gnuplot 'splot'
void print_gridfn(int gfn, FILE *output_fp = stdout) const;
void print_ghosted_gridfn(int gfn, bool want_ghost_zones = true,
FILE *output_fp = stdout) const;
//
// ***** constructor, destructor *****
//
// This constructor doesn't support the full generality of the
// patch data structures (which would, eg, allow N_ghost_points
// and N_extend_points and the interpolator parameters to vary
// from ghost zone to ghost zone, and the grid spacings to vary
// from patch to patch. But in practice we'd probably never
// use that generality...
//
public:
patch_system(fp origin_x_in, fp origin_y_in, fp origin_z_in,
enum patch_system_type type_in,
int N_ghost_points, int N_overlap_points,
fp delta_drho_dsigma,
int min_gfn_in, int max_gfn_in,
int ghosted_min_gfn_in, int ghosted_max_gfn_in,
int interp_handle_in, int interp_par_table_handle_in);
~patch_system();
//
// ***** helper functions for constructor *****
//
private:
// construct patches as described by patch_info[] array,
// and link them into the patch system
// does *NOT* create ghost zones or frontiers
// does *NOT* set up gridfns
void create_patches(const struct patch_info patch_info_in[],
int N_ghost_points, int N_extend_points,
fp delta_drho_dsigma);
// setup all gridfns with contiguous-across-patches storage
void setup_gridfn_storage
(int min_gfn_in, int max_gfn_in,
int ghosted_min_gfn_in, int ghosted_max_gfn_in);
// create/interlink ghost zones and frontiers
void interlink_full_sphere_patch_system
(int N_overlap_points,
int interp_handle, int interp_par_table_handle);
void interlink_plus_z_hemisphere_patch_system
(int N_overlap_points,
int interp_handle, int interp_par_table_handle);
void interlink_plus_xy_quadrant_patch_system
(int N_overlap_points,
int interp_handle, int interp_par_table_handle);
void interlink_plus_xz_quadrant_patch_system
(int N_overlap_points,
int interp_handle, int interp_par_table_handle);
void interlink_plus_xyz_octant_patch_system
(int N_overlap_points,
int interp_handle, int interp_par_table_handle);
// create/interlink a pair of periodic-symmetry ghost zones
static
void create_periodic_symmetry_ghost_zones
(const patch_edge& ex, const patch_edge& ey,
bool ipar_map_is_plus);
// construct a pair of interpatch ghost zones
// ... automagically figures out which edges are adjacent
static
void create_interpatch_ghost_zones(patch &px, patch &py,
int N_overlap_points);
// finish setup of a pair of interpatch ghost zones,
// setup the corresponding patch frontiers
// ... automagically figures out which edges are adjacent
static
void finish_interpatch_setup
(patch &px, patch &py,
int N_overlap_points,
int interp_handle, int interp_par_table_handle);
// assert() that all ghost zones (and frontiers, where applicable)
// of all patches are fully setup
void assert_all_ghost_zones_fully_setup() const;
private:
// we forbid copying and passing by value
// by declaring the copy constructor and assignment operator
// private, but never defining them
patch_system(const patch_system &rhs);
patch_system& operator=(const patch_system &rhs);
private:
// local <--> global coordinate mapping
global_coords global_coords_;
// meta-info about patch system
enum patch_system_type type_;
int N_patches_;
int N_grid_points_, ghosted_N_grid_points_;
// pointers to individual patches
std::vector<patch *> all_patches_;
// pointers to storage blocks for all gridfns
// ... patches point into these, but we own the storage blocks
fp* gridfn_storage_;
fp* ghosted_gridfn_storage_;
};
|
