llc_1080/code-async/SIZE.h


#if 0

  The somewhat weird looking format of this file is so that it can be
  included in both C and FORTRAN routines.  The general problem is that
  FORTRAN requires that the definitions in this header file be included
  in each *subroutine*, and thus possibly multiple times in a single
  source file if that source file defines multiple subroutines, while C
  demands that the actual definitions only appear once per *file*, even
  if this header file is (accidently) #include'd multiple times.

  N.B.: Do NOT remove the parentheses in the "enum" or "PARAMETER"
  declarations.  We want the user to be able to use an expression
  in the "#define" (e.g. "#define __sNx    64 + 8 "), and not have
  to worry about precedence in the substituted expressions (e.g.
  if "__sNx" is defined as 64 + 8, then "__sNx * __sNy" would not
  behave the way you might expect, unlike "(__sNx) * (__sNy)").

#endif


#if 0
  Define the magic constants.  If you want to add (or delete) entries,
  note that the change needs to also be made to the C "enum" and the
  Fortran "parameter" statements.

    __sFacet : The fundamental unit size of a facet in llc.  Facets
               one and two are 1unit x 3units, facet three (the arctic
               polar facet) is 1unit x 1unit, and facets four and five
               are 3units x 1unit.

    __sNx, __sNy : The (sub)tile dimensions.  Each must divide __sFacet.
                   Note that if sub-tiles are being used (i.e. __nSx
                   and/or __nSy are greater than one), these dimensions
                   are the extent of each sub-tile.

    __OLx, __OLy : The overlap, i.e. the number of ghost cells.

    __nSx, __nSy : If the code uses parallel threads in (addition to MPI),
                   the sub-division of an individual tile into sub-tiles.
                   An MPI process is assigned a whole tile, and each thread
                   within that process is assigned a sub-tile.  Thus, each
                   MPI process will use (__nSx * __nSy) threads.  These
                   values are usually both "1" (i.e. no threading).

    __nPx, __nPy : The full llc decomposition of the earth contains
                     (__sFacet/__sNx) * (__sFacet/__sNy) * 13
                   total tiles.  However, some of these tiles represent
                   areas that have no water, and so MITgcm doesn't care
                   about them. (These are called "dry" tiles, or "blank"
                   tiles.)  We take that sub-set of the tiles we care
                   about (i.e. the "wet" tiles; the ones we are actually
                   going to do computations on), and imagine those tiles
                   being in a 2D array, with extent (__nPx, __nPy).
                   As a practical matter, for the llc decomposition,
                   __nPy is almost always 1 (and __nPx is equal to the
                   number of "wet" tiles).

    __Nr : The number of vertical levels in the 3D fields.
#endif

#if !defined(_MITGCM_MAGIC_CONSTANTS)
#define _MITGCM_MAGIC_CONSTANTS

#define __sFacet 1080
#define __sNx  90
#define __sNy  90
#define __OLx   8
#define __OLy   8
#define __nSx   1
#define __nSy   1
#define __nPx  1872-530
#define __nPy   1
#define __Nr   90

#endif


#if defined(__STDC__) || defined(__cplusplus)

/* For C, only include this part once */
#if !defined(SIZE_h)
#define SIZE_h

/*
** We use the "enum" hack in order to force the names into the symbol
** table, which "#define" by itself typically does not do.
*/
enum {
  sFacet = (__sFacet),
  sNx = (__sNx),
  sNy = (__sNy),
  OLx = (__OLx),
  OLy = (__OLy),
  nSx = (__nSx),
  nSy = (__nSy),
  nPx = (__nPx),
  nPy = (__nPy),
  Nr  = (__Nr),

  Nx  = ((__sNx)*(__nSx)*(__nPx)),
  Ny  = ((__sNy)*(__nSy)*(__nPy)),
  MAX_OLX  = (OLx),
  MAX_OLY  = (OLy),
};

/* end of "if !defined(SIZE_h)" */
#endif


#else


! There are no pre-processor symbols that are guarenteed to be defined
! for a Fortran compile, so we just assume that since this wasn't C/C++,
! it must be Fortran.

C $Header: /u/gcmpack/MITgcm_contrib/llc_hires/llc_4320/code/SIZE.h_45x45x73408,v 1.2 2016/04/14 03:51:44 dimitri Exp $
C $Name:  $
C
CBOP
C    !ROUTINE: SIZE.h
C    !INTERFACE:
C    include SIZE.h
C    !DESCRIPTION: \bv
C     *==========================================================*
C     | SIZE.h Declare size of underlying computational grid.     
C     *==========================================================*
C     | The design here support a three-dimensional model grid    
C     | with indices I,J and K. The three-dimensional domain      
C     | is comprised of nPx*nSx blocks of size sNx along one axis 
C     | nPy*nSy blocks of size sNy along another axis and one     
C     | block of size Nz along the final axis.                    
C     | Blocks have overlap regions of size OLx and OLy along the 
C     | dimensions that are subdivided.                           
C     *==========================================================*
C     \ev
CEOP
C     Voodoo numbers controlling data layout.
C     sNx :: No. X points in sub-grid.
C     sNy :: No. Y points in sub-grid.
C     OLx :: Overlap extent in X.
C     OLy :: Overlat extent in Y.
C     nSx :: No. sub-grids in X.
C     nSy :: No. sub-grids in Y.
C     nPx :: No. of processes to use in X.
C     nPy :: No. of processes to use in Y.
C     Nx  :: No. points in X for the total domain.
C     Ny  :: No. points in Y for the total domain.
C     Nr  :: No. points in Z for full process domain.

      INTEGER sFacet
      INTEGER sNx
      INTEGER sNy
      INTEGER OLx
      INTEGER OLy
      INTEGER nSx
      INTEGER nSy
      INTEGER nPx
      INTEGER nPy
      INTEGER Nx
      INTEGER Ny
      INTEGER Nr

      PARAMETER (
     &           sFacet =  (__sFacet),
     &           sNx =  (__sNx),
     &           sNy =  (__sNy),
     &           OLx =  (__OLx),
     &           OLy =  (__OLy),
     &           nSx =  (__nSx),
     &           nSy =  (__nSy),
     &           nPx =  (__nPx),
     &           nPy =  (__nPy),
     &           Nr  =  (__Nr)  )

      PARAMETER ( Nx = (__sNx)*(__nSx)*(__nPx) )
      PARAMETER ( Ny = (__sNy)*(__nSy)*(__nPy) )

C     MAX_OLX :: Set to the maximum overlap region size of any array
C     MAX_OLY    that will be exchanged. Controls the sizing of exch
C                routine buffers.
      INTEGER MAX_OLX
      INTEGER MAX_OLY
      PARAMETER ( MAX_OLX = (OLx),
     &            MAX_OLY = (OLy) )


#endif

1
2	#if 0
3
4	The somewhat weird looking format of this file is so that it can be
5	included in both C and FORTRAN routines. The general problem is that
6	FORTRAN requires that the definitions in this header file be included
7	in each subroutine, and thus possibly multiple times in a single
8	source file if that source file defines multiple subroutines, while C
9	demands that the actual definitions only appear once per file, even
10	if this header file is (accidently) #include'd multiple times.
11
12	N.B.: Do NOT remove the parentheses in the "enum" or "PARAMETER"
13	declarations. We want the user to be able to use an expression
14	in the "#define" (e.g. "#define __sNx 64 + 8 "), and not have
15	to worry about precedence in the substituted expressions (e.g.
16	if "__sNx" is defined as 64 + 8, then "__sNx * __sNy" would not
17	behave the way you might expect, unlike "(__sNx) * (__sNy)").
18
19	#endif
20
21
22
23	#if 0
24	Define the magic constants. If you want to add (or delete) entries,
25	note that the change needs to also be made to the C "enum" and the
26	Fortran "parameter" statements.
27
28	__sFacet : The fundamental unit size of a facet in llc. Facets
29	one and two are 1unit x 3units, facet three (the arctic
30	polar facet) is 1unit x 1unit, and facets four and five
31	are 3units x 1unit.
32
33	__sNx, __sNy : The (sub)tile dimensions. Each must divide __sFacet.
34	Note that if sub-tiles are being used (i.e. __nSx
35	and/or __nSy are greater than one), these dimensions
36	are the extent of each sub-tile.
37
38	__OLx, __OLy : The overlap, i.e. the number of ghost cells.
39
40	__nSx, __nSy : If the code uses parallel threads in (addition to MPI),
41	the sub-division of an individual tile into sub-tiles.
42	An MPI process is assigned a whole tile, and each thread
43	within that process is assigned a sub-tile. Thus, each
44	MPI process will use (__nSx * __nSy) threads. These
45	values are usually both "1" (i.e. no threading).
46
47	__nPx, __nPy : The full llc decomposition of the earth contains
48	(__sFacet/__sNx) * (__sFacet/__sNy) * 13
49	total tiles. However, some of these tiles represent
50	areas that have no water, and so MITgcm doesn't care
51	about them. (These are called "dry" tiles, or "blank"
52	tiles.) We take that sub-set of the tiles we care
53	about (i.e. the "wet" tiles; the ones we are actually
54	going to do computations on), and imagine those tiles
55	being in a 2D array, with extent (__nPx, __nPy).
56	As a practical matter, for the llc decomposition,
57	__nPy is almost always 1 (and __nPx is equal to the
58	number of "wet" tiles).
59
60	__Nr : The number of vertical levels in the 3D fields.
61	#endif
62
63	#if !defined(_MITGCM_MAGIC_CONSTANTS)
64	#define _MITGCM_MAGIC_CONSTANTS
65
66	#define __sFacet 1080
67	#define __sNx 90
68	#define __sNy 90
69	#define __OLx 8
70	#define __OLy 8
71	#define __nSx 1
72	#define __nSy 1
73	#define __nPx 1872-530
74	#define __nPy 1
75	#define __Nr 90
76
77	#endif
78
79
80
81
82	#if defined(__STDC__) \|\| defined(__cplusplus)
83
84	/* For C, only include this part once */
85	#if !defined(SIZE_h)
86	#define SIZE_h
87
88	/*
89	** We use the "enum" hack in order to force the names into the symbol
90	** table, which "#define" by itself typically does not do.
91	*/
92	enum {
93	sFacet = (__sFacet),
94	sNx = (__sNx),
95	sNy = (__sNy),
96	OLx = (__OLx),
97	OLy = (__OLy),
98	nSx = (__nSx),
99	nSy = (__nSy),
100	nPx = (__nPx),
101	nPy = (__nPy),
102	Nr = (__Nr),
103
104	Nx = ((__sNx)(__nSx)(__nPx)),
105	Ny = ((__sNy)(__nSy)(__nPy)),
106	MAX_OLX = (OLx),
107	MAX_OLY = (OLy),
108	};
109
110	/* end of "if !defined(SIZE_h)" */
111	#endif
112
113
114	#else
115
116
117	! There are no pre-processor symbols that are guarenteed to be defined
118	! for a Fortran compile, so we just assume that since this wasn't C/C++,
119	! it must be Fortran.
120
121	C $Header: /u/gcmpack/MITgcm_contrib/llc_hires/llc_4320/code/SIZE.h_45x45x73408,v 1.2 2016/04/14 03:51:44 dimitri Exp $
122	C $Name: $
123	C
124	CBOP
125	C !ROUTINE: SIZE.h
126	C !INTERFACE:
127	C include SIZE.h
128	C !DESCRIPTION: \bv
129	C ==========================================================
130	C \| SIZE.h Declare size of underlying computational grid.
131	C ==========================================================
132	C \| The design here support a three-dimensional model grid
133	C \| with indices I,J and K. The three-dimensional domain
134	C \| is comprised of nPx*nSx blocks of size sNx along one axis
135	C \| nPy*nSy blocks of size sNy along another axis and one
136	C \| block of size Nz along the final axis.
137	C \| Blocks have overlap regions of size OLx and OLy along the
138	C \| dimensions that are subdivided.
139	C ==========================================================
140	C \ev
141	CEOP
142	C Voodoo numbers controlling data layout.
143	C sNx :: No. X points in sub-grid.
144	C sNy :: No. Y points in sub-grid.
145	C OLx :: Overlap extent in X.
146	C OLy :: Overlat extent in Y.
147	C nSx :: No. sub-grids in X.
148	C nSy :: No. sub-grids in Y.
149	C nPx :: No. of processes to use in X.
150	C nPy :: No. of processes to use in Y.
151	C Nx :: No. points in X for the total domain.
152	C Ny :: No. points in Y for the total domain.
153	C Nr :: No. points in Z for full process domain.
154
155	INTEGER sFacet
156	INTEGER sNx
157	INTEGER sNy
158	INTEGER OLx
159	INTEGER OLy
160	INTEGER nSx
161	INTEGER nSy
162	INTEGER nPx
163	INTEGER nPy
164	INTEGER Nx
165	INTEGER Ny
166	INTEGER Nr
167
168	PARAMETER (
169	& sFacet = (__sFacet),
170	& sNx = (__sNx),
171	& sNy = (__sNy),
172	& OLx = (__OLx),
173	& OLy = (__OLy),
174	& nSx = (__nSx),
175	& nSy = (__nSy),
176	& nPx = (__nPx),
177	& nPy = (__nPy),
178	& Nr = (__Nr) )
179
180	PARAMETER ( Nx = (__sNx)(__nSx)(__nPx) )
181	PARAMETER ( Ny = (__sNy)(__nSy)(__nPy) )
182
183	C MAX_OLX :: Set to the maximum overlap region size of any array
184	C MAX_OLY that will be exchanged. Controls the sizing of exch
185	C routine buffers.
186	INTEGER MAX_OLX
187	INTEGER MAX_OLY
188	PARAMETER ( MAX_OLX = (OLx),
189	& MAX_OLY = (OLy) )
190
191
192	#endif
193