atlas
CubedSphereGrid.h
1 /*
2  * (C) Copyright 2020 UCAR
3  *
4  * This software is licensed under the terms of the Apache Licence Version 2.0
5  * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
6  */
7 
8 #pragma once
9 
10 #include <string>
11 
12 #include "atlas/grid/Grid.h"
13 #include "atlas/grid/Tiles.h"
14 #include "atlas/grid/detail/grid/CubedSphere.h"
15 
16 namespace atlas {
17 
18 //---------------------------------------------------------------------------------------------------------------------
19 class CubedSphereGrid;
20 
21 /*
22  Grid
23  |
24  +----------+----------+-------------------------------+
25  | | |
26  StructuredGrid UnstructuredGrid CubedSphere
27  |
28  +--------------------+-----------------------+
29  | | |
30  ReducedGrid GaussianGrid RegularGrid
31  | | | | |
32  +--------+--------+ +--------+--------+ +-----+
33  | | |
34  ReducedGaussianGrid RegularGaussianGrid RegularLonLatGrid
35 */
36 
37 //---------------------------------------------------------------------------------------------------------------------
38 
47 /*
48 Description of indices
49 ----------------------
50 This class and the implementations in detail/grid/CubedSphere.h are for the structured cubed-sphere
51 grid.
52 
53 In the following there are indices in the grid, denoted idx_t i, idx_t j, idx_t t and positions in
54 the grid, denoted double x, double y and t. For the cubed-sphere each face of the tile is
55 represented by rank 2 arrays with index in that array denoted by i and j. The face is denoted by t.
56 
57 For a regular like grid, translating between i, j and x, y could be done from a starting point and
58 the grid spacing. But this is not possible for the cubed-sphere grid, where the spacing is not
59 necessarily regular and the array not rank 2 for the entire grid, i.e. is made more complicated
60 by the tile index.
61 
62 x and y represent the position on a plane with the tiles arranged in an 'unfolded manner', shown
63 below. Tile t is carried around also as part of the array xy in order to do the projection properly.
64 
65 Cubed-sphere Panel Arrangement:
66 
67 y
68 
69 ^ .......
70 | | :
71 | | 2 :
72 | | :
73 | --->---
74 | *....... ....... ------- -------
75 | | :| :| :| :
76 | | 0 :| 1 :v 3 :v 4 :
77 | | :| :| :| :
78 | --->--- --->--* ....... .......
79 | -------
80 | | :
81 | v 5 :
82 | | :
83 | .......
84 -----------------------------------------------------------> x
85 
86 Key
87 Solid lines: left and bottom edges of panel
88 Dotted lines: right and top edges of panel
89 >, <, v: direction of increasing index in first dimension
90 *: location of two extra points (ngrid = 6 * NCube * NCube + 2)
91 
92 ----------------------------------------------------------------------------------------------------
93 
94 NCube = 3 example ( 6 * NCube * NCube + 2 = 56 grid points )
95 
96 Index of each point within the grid (i,j,t):
97 
98  () denotes actual points in the grids
99  <> denotes points that are duplicates (not part of the grid) but shown for completeness of the grid
100 
101 
102 
103  <0,3,0>-<0,2,4>-<0,1,4>-<0,0,4>
104  | |
105  | |
106  (0,1,2) (1,2,2) (2,2,2) <0,2,3>
107  | |
108  | |
109  (0,1,2) (1,1,2) (2,1,2) <0,1,3>
110  | |
111  | |
112 (0,3,0)-<0,1,2>-<0,1,2>-(0,0,2)-(1,0,2)-(2,0,2)-(0,0,3)-(0,1,3)-(0,2,3)-(0,0,4)-(0,1,4)-(0,2,4)-<0,3,0>
113  | | | | |
114  | | | | |
115 (0,2,0) (1,2,0) (2,2,0) (0,1,1) (1,2,1) (2,2,1) (1,0,3) (1,1,3) (1,2,3) (1,0,4) (1,1,4) (1,2,4) <0,1,0>
116  | | | | |
117  | | | | |
118 (0,1,0) (1,1,0) (2,1,0) (0,1,1) (1,1,1) (2,1,1) (2,0,3) (2,1,3) (2,2,3) (2,0,4) (2,1,4) (2,2,4) <0,1,0>
119  | | | | |
120  | | | | |
121 (0,0,0)-(1,0,0)-(2,0,0)-(0,0,1)-(1,0,1)-(2,0,1)-(3,0,1)-<2,0,5>-<1,0,5>-(0,0,5)-(0,1,5)-(0,2,5)-<0,0,0>
122  | |
123  | |
124  (1,0,5) (1,1,5) (1,2,5) <1,0,0>
125  | |
126  | |
127  (2,0,5) (2,1,5) (2,2,5) <2,0,0>
128  | |
129  | |
130  <3,0,1>-<2,0,1>-<1,0,1>-<0,0,1>
131 
132 
133 
134 Position of each point within the grid (x,y,t):
135 
136  () denotes actual points in the grids
137  + denotes duplicate points
138 
139  For the xyt, t is only required in order to pass to the projection and thus know how to rotate
140  the projection of tile 0 to obtain the other tiles
141 
142 
143  +-------+-------+-------+
144  | |
145  | |
146  (3,8,2) (4,8,2) (5,8,2) +
147  | |
148  | |
149  (3,7,2) (4,7,2) (5,7,2) +
150  | |
151  | |
152 (0,6,0)----+-------+----(3,6,2)-(4,6,2)-(5,6,2)-(6,6,3)-(7,6,3)-(8,6,3)-(9,6,4)-(10,6,4)-(11,6,4)----+
153  | | | | |
154  | | | | |
155 (0,5,0) (1,5,0) (2,5,0) (3,5,1) (4,5,1) (5,5,1) (6,5,3) (7,5,3) (8,5,3) (9,5,4) (10,5,4) (11,5,4) +
156  | | | | |
157  | | | | |
158 (0,4,0) (1,4,0) (2,4,0) (3,4,1) (4,4,1) (5,4,1) (6,4,3) (7,4,3) (8,4,3) (9,4,4) (10,4,4) (11,4,4) +
159  | | | | |
160  | | | | |
161 (0,3,0)-(1,3,0)-(2,3,0)-(3,3,1)-(4,3,1)-(5,3,1)-(6,3,1)----+-------+----(9,3,5)-(10,3,5)-(11,3,5)----+
162  | |
163  | |
164  (9,2,5) (10,2,5) (11,2,5) +
165  | |
166  | |
167  (9,1,5) (10,1,5) (11,1,5) +
168  | |
169  | |
170  +--------+-------+--------+
171 
172 
173 Position in the grid iterator/mesh:
174 
175  First element of each tile: {0, 10, 20, 29, 38, 47}
176 
177  +---+---+---+
178  | |
179  26 27 28 +
180  | |
181  23 24 25 +
182  | |
183  9---+---+--20--21--22--29--32--35---38--41--44---+
184  | | | | |
185  6 7 8 17 18 19 30 33 36 39 42 45 +
186  | | | | |
187  3 4 5 14 15 16 31 34 37 40 43 46 +
188  | | | | |
189  0---1---2--10--11--12--13---+---+---47--50--53---+
190  | |
191  48 51 54 +
192  | |
193  49 52 55 +
194  | |
195  +---+---+---+
196 
197 ----------------------------------------------------------------------------------------------------
198 
199 */
200 
201 
202 namespace temporary {
203 
204 class IteratorTIJ {
205  using implementation_t = grid::detail::grid::CubedSphere::IteratorTIJ;
206 
207 public:
208  using difference_type = implementation_t::difference_type;
209  using iterator_category = implementation_t::iterator_category;
210  using value_type = implementation_t::value_type;
211  using pointer = implementation_t::pointer;
212  using reference = implementation_t::reference;
213 
214 public:
215  IteratorTIJ( std::unique_ptr<implementation_t> iterator ) : iterator_( std::move( iterator ) ) {}
216 
217  bool next( value_type& xy ) { return iterator_->next( xy ); }
218 
219  reference operator*() const { return iterator_->operator*(); }
220 
221  const IteratorTIJ& operator++() {
222  iterator_->operator++();
223  return *this;
224  }
225 
226  const IteratorTIJ& operator+=( difference_type distance ) {
227  iterator_->operator+=( distance );
228  return *this;
229  }
230 
231  friend difference_type operator-( const IteratorTIJ& last, const IteratorTIJ& first ) {
232  return first.iterator_->distance( *last.iterator_ );
233  }
234 
235  bool operator==( const IteratorTIJ& other ) const { return iterator_->operator==( *other.iterator_ ); }
236  bool operator!=( const IteratorTIJ& other ) const { return iterator_->operator!=( *other.iterator_ ); }
237 
238 private:
239  difference_type distance( const IteratorTIJ& other ) const { return iterator_->distance( *other.iterator_ ); }
240 
241 private:
242  std::unique_ptr<implementation_t> iterator_;
243 };
244 
245 class IterateTIJ {
246 public:
247  using iterator = IteratorTIJ;
248  using const_iterator = iterator;
249  using Grid = grid::detail::grid::CubedSphere;
250 
251 public:
252  IterateTIJ( const Grid& grid ) : grid_( grid ) {}
253  iterator begin() const { return grid_.tij_begin(); }
254  iterator end() const { return grid_.tij_end(); }
255 
256 private:
257  const Grid& grid_;
258 };
259 
260 
261 } // namespace temporary
262 
263 
264 class CubedSphereGrid : public Grid {
265 public:
266  using grid_t = grid::detail::grid::CubedSphere;
267 
268 public:
269  CubedSphereGrid();
270  CubedSphereGrid( const Grid& );
271  CubedSphereGrid( const Grid::Implementation* );
272  CubedSphereGrid( const std::string& name );
273  CubedSphereGrid( const Config& );
274  CubedSphereGrid( const int&, const Projection& = Projection() );
275 
276  operator bool() const { return valid(); }
277 
278  bool valid() const { return grid_; }
279 
280  using Grid::xy;
281  void xyt( idx_t i, idx_t j, idx_t t, double xyt[] ) const { grid_->xyt( i, j, t, xyt ); }
282  PointXY xyt( idx_t i, idx_t j, idx_t t ) const { return grid_->xyt( i, j, t ); }
283  // Given indexes in the array (i, j, t) return position array xyt
284 
285  void xy( idx_t i, idx_t j, idx_t t, double xy[] ) const { grid_->xy( i, j, t, xy ); }
286  PointXY xy( idx_t i, idx_t j, idx_t t ) const { return grid_->xy( i, j, t ); }
287 
288  using Grid::lonlat;
289  // Given indexes in the array (i, j) return lat/lon array (via the projection)
290  void lonlat( idx_t i, idx_t j, idx_t t, double lonlat[] ) const { grid_->lonlat( i, j, t, lonlat ); }
291 
292  // Given indexes in the array (i, j, t) return lat/lon as a PointLonLat object
293  PointLonLat lonlat( idx_t i, idx_t j, idx_t t ) const { return grid_->lonlat( i, j, t ); }
294 
295  // Return the size of the cubed sphere grid, where N is the number of grid boxes along the edge of a tile
296  inline int N() const { return grid_->N(); }
297 
298  // Return the number of tiles
299  inline atlas::grid::CubedSphereTiles tiles() const { return grid_->tiles(); }
300 
301  temporary::IterateTIJ tij() const { return temporary::IterateTIJ( *grid_ ); }
302 
303  const std::string& stagger() const { return grid_->stagger(); }
304 
305 private:
306  const grid_t* grid_;
307 };
308 
309 //---------------------------------------------------------------------------------------------------------------------
310 
311 } // namespace atlas
atlas::PointLonLat
Point in longitude-latitude coordinate system.
Definition: Point.h:103
atlas::Projection
Definition: Projection.h:49
atlas::temporary::IterateTIJ
Definition: CubedSphereGrid.h:245
atlas::Grid
Most general grid container.
Definition: Grid.h:64
atlas::grid::detail::grid::CubedSphere
Definition: CubedSphere.h:49
atlas::grid::CubedSphereTiles
Definition: Tiles.h:48
atlas::PointXY
Point in arbitrary XY-coordinate system.
Definition: Point.h:40
atlas
Contains all atlas classes and methods.
Definition: atlas-grids.cc:33
atlas::idx_t
long idx_t
Integer type for indices in connectivity tables.
Definition: config.h:42
atlas::temporary::IteratorTIJ
Definition: CubedSphereGrid.h:204
atlas::CubedSphereGrid
Specialization of Grid, where the grid is a cubed sphere.
Definition: CubedSphereGrid.h:264
atlas::util::Config
Configuration class used to construct various atlas components.
Definition: Config.h:27
Generated by   doxygen 1.8.13