source: CIVL/mods/dev.civl.abc/examples/fortran/flash/block/gr_createDomain.F90

main
Last change on this file was aad342c, checked in by Stephen Siegel <siegel@…>, 3 years ago

Performing huge refactor to incorporate ABC, GMC, and SARL into CIVL repo and use Java modules.

git-svn-id: ​svn://vsl.cis.udel.edu/civl/trunk@5664 fb995dde-84ed-4084-dfe6-e5aef3e2452c
  • Property mode set to 100644
File size: 7.0 KB
Line 
1!!****if* source/Grid/GridMain/UG/gr_createDomain
2!!
3!! NAME
4!!
5!! gr_createDomain
6!!
7!!
8!! SYNOPSIS
9!!
10!! gr_createDomain()
11!!
12!!
13!!
14!! DESCRIPTION
15!!
16!! Creates the Uniform Grid domain. The Uniform Grid expects to be
17!! given the processor grid at runtime in the form of runtime parameters
18!! iprocs,jprocs and kprocs, where iprocs*jprocs*kprocs is the
19!! number of processor in the run. If UG is running in fixed
20!! blocksize mode, then the blocksizes NXB, NYB and NZB are specified
21!! at compile time. One block is placed on each processor, so that
22!! the global domain size is <NXB*iprocs, NYB*jprocs, NZB*kprocs>.
23!! However, if UG is running in non-fixed blocksize mode, the
24!! blocksize is determined at runtime. In this mode, UG expects to be
25!! given the global domain size in form of runtime parameters
26!! iGridSize,jGridSize and kGridSize, and the blocksize is <iGridSize
27!!/iprocs,jGridSize/jprocs,kGridSize/kprocs>. As in fixedblocksize mode,
28!! only one blocks is placed on each processor
29!!
30!! This routine also creates directional communicators used in
31!! guardcell exchanges, allocates space for storing physical
32!! coordinates of grid points, and computes them.
33!!
34!!
35!! ARGUMENTS
36!!
37!!
38!!
39!!***
40
41#ifdef DEBUG_ALL
42#define DEBUG_GRID
43#endif
44
45subroutine gr_createDomain()
46
47 use physicalData, ONLY : unk, facevarx,facevary,facevarz
48
49 use Grid_data, ONLY : scratch,scratch_ctr,&
50 &scratch_facevarx,scratch_facevary,scratch_facevarz
51
52 use Grid_data, ONLY : gr_axisMe, gr_axisNumProcs,&
53 gr_guard, &
54 gr_gIndexSize, gr_blkCornerID, &
55 gr_lIndexSize, gr_kmax, gr_kmin, &
56 gr_jmax, gr_jmin, gr_imax, gr_imin, gr_delta, gr_blkBC, &
57 gr_iCoords, gr_jCoords, gr_kCoords, gr_domainBC, gr_iLoGC, &
58 gr_jLoGC, gr_kLoGC, gr_iHiGC, gr_jHiGC, gr_kHiGC,&
59 gr_ilo,gr_ihi,gr_jlo,gr_jhi,gr_klo,gr_khi,&
60 gr_iguard,gr_jguard,gr_kguard
61
62
63 implicit none
64
65#include "constants.h"
66#include "Flash.h"
67 include "Flash_mpi.h"
68
69 integer :: ierr
70 integer :: color, key, range_b, range_e
71 real :: halfDelta
72 integer :: i,j
73
74
75
76
77 !store local index size for each block
78 gr_lIndexSize = gr_gIndexSize/gr_axisNumProcs
79
80 !store lower left global index for each dim
81 gr_blkCornerID = gr_axisMe*gr_lIndexSize+1
82
83
84 gr_iloGc = 1
85 gr_ilo = gr_iloGc+gr_guard(IAXIS)
86 gr_ihi = gr_ilo+gr_lIndexSize(IAXIS) -1
87 gr_ihiGc = gr_ihi + gr_guard(IAXIS)
88 gr_iguard = gr_guard(IAXIS)
89
90
91 if(NDIM>1)then
92
93 gr_jloGc = 1
94 gr_jlo = gr_jloGc+gr_guard(JAXIS)
95 gr_jhi = gr_jlo+gr_lIndexSize(JAXIS) -1
96 gr_jhiGc = gr_jhi + gr_guard(JAXIS)
97 gr_jguard = gr_guard(JAXIS)
98
99 else
100 gr_jloGc = 1
101 gr_jlo = 1
102 gr_jhi = 1
103 gr_jhiGc = 1
104 gr_jguard = 0
105 end if
106
107
108 if(NDIM>2)then
109 gr_kloGc = 1
110 gr_klo = gr_kloGc+gr_guard(KAXIS)
111 gr_khi = gr_klo+gr_lIndexSize(KAXIS) -1
112 gr_khiGc = gr_khi + gr_guard(KAXIS)
113 gr_kguard = gr_guard(KAXIS)
114
115 else
116 gr_klo=1
117 gr_kloGc=1
118 gr_khi = 1
119 gr_khiGc = 1
120 gr_kguard = 0
121 endif
122
123 !! Now create the grid and coordinates etc
124 allocate(gr_iCoords(3,gr_ihiGc-gr_iloGc+1,1))
125 allocate(gr_jCoords(3,gr_jhiGc-gr_jloGc+1,1))
126 allocate(gr_kCoords(3,gr_khiGc-gr_kloGc+1,1))
127
128#ifndef FIXEDBLOCKSIZE
129
130 allocate(unk(UNK_VARS_BEGIN:UNK_VARS_END,&
131 gr_iLoGc:gr_iHiGc, gr_jLoGc:gr_jHiGc,&
132 gr_kLoGc:gr_kHiGc,1))
133
134
135#if(NFACE_VARS>0)
136
137 allocate(facevarx( NFACE_VARS,&
138 gr_iLoGc:gr_iHiGc+1, gr_jLoGc:gr_jHiGc,&
139 gr_kLoGc:gr_kHiGc,1))
140
141 allocate(facevary( NFACE_VARS,&
142 gr_iLoGc:gr_iHiGc, gr_jLoGc:gr_jHiGc+K2D,&
143 gr_kLoGc:gr_kHiGc,1))
144
145 allocate(facevarz( NFACE_VARS,&
146 gr_iLoGc:gr_iHiGc, gr_jLoGc:gr_jHiGc,&
147 gr_kLoGc:gr_kHiGc+K3D,1) )
148
149#else
150 allocate(facevarx(1,1,1,1,1))
151 allocate(facevarz(1,1,1,1,1))
152 allocate(facevary(1,1,1,1,1))
153#endif
154#if NSCRATCH_GRID_VARS > 0
155 allocate(scratch(SCRATCH_GRID_VARS_BEGIN:SCRATCH_GRID_VARS_END,&
156 gr_iLoGc:gr_iHiGc+1, gr_jLoGc:gr_jHiGc+1,&
157 gr_kLoGc:gr_kHiGc+1,1))
158#else
159 allocate(scratch(1,1,1,1,1))
160#endif
161
162#if NSCRATCH_CENTER_VARS > 0
163 allocate(scratch_ctr(SCRATCH_CENTER_VARS_BEGIN:SCRATCH_CENTER_VARS_END,&
164 gr_iLoGc:gr_iHiGc, gr_jLoGc:gr_jHiGc,&
165 gr_kLoGc:gr_kHiGc,1))
166#else
167 allocate(scratch_ctr(1,1,1,1,1))
168#endif
169
170#if(NSCRATCH_FACEX_VARS>0)
171 allocate(scratch_facevarx( SCRATCH_FACEX_VARS_BEGIN:SCRATCH_FACEX_VARS_END,&
172 gr_iLoGc:gr_iHiGc+1, gr_jLoGc:gr_jHiGc,&
173 gr_kLoGc:gr_kHiGc,1))
174#else
175 allocate(scratch_facevarx(1,1,1,1,1))
176#endif
177
178#if(NSCRATCH_FACEY_VARS>0)
179 allocate(scratch_facevary( SCRATCH_FACEY_VARS_BEGIN:SCRATCH_FACEY_VARS_END,&
180 gr_iLoGc:gr_iHiGc, gr_jLoGc:gr_jHiGc+K2D,&
181 gr_kLoGc:gr_kHiGc,1))
182#else
183 allocate(scratch_facevary(1,1,1,1,1))
184#endif
185
186#if(NSCRATCH_FACEZ_VARS>0)
187 allocate(scratch_facevarz( SCRATCH_FACEZ_VARS_BEGIN:SCRATCH_FACEZ_VARS_END,&
188 gr_iLoGc:gr_iHiGc, gr_jLoGc:gr_jHiGc,&
189 gr_kLoGc:gr_kHiGc+K3D,1) )
190#else
191 allocate(scratch_facevarz(1,1,1,1,1))
192#endif
193
194#endif
195
196#ifdef DEBUG_GRID
197 write(6,*)'gr_gIndexSize', gr_gIndexSize
198 write(6,*)'gr_lIndexSize',gr_lIndexSize
199 write(6,*)'gr_blkCornerID',gr_blkCornerID
200#endif
201 gr_delta(IAXIS) = (gr_imax-gr_imin)/gr_gIndexSize(IAXIS)
202
203 halfDelta = gr_delta(IAXIS)/2.0
204 j = gr_blkCornerID(IAXIS)-gr_guard(IAXIS)-1
205
206 do i = gr_iloGc,gr_ihiGc
207 gr_iCoords(LEFT_EDGE,i,1) = gr_imin+j*gr_delta(IAXIS)
208 gr_iCoords(CENTER,i,1) = gr_imin+j*gr_delta(IAXIS)+halfDelta
209 j = j+1
210 gr_iCoords(RIGHT_EDGE,i,1) = gr_imin+j*gr_delta(IAXIS)
211 end do
212 gr_blkBC = gr_domainBC
213 if(gr_axisMe(IAXIS)/=0)gr_blkBC(LOW,IAXIS)=NOT_BOUNDARY
214 if(gr_axisMe(IAXIS)/=(gr_axisNumProcs(IAXIS)-1))&
215 gr_blkBC(HIGH,IAXIS)=NOT_BOUNDARY
216
217 if(NDIM > 1) then
218 gr_delta(JAXIS) = (gr_jmax-gr_jmin)/gr_gIndexSize(JAXIS)
219 halfDelta = gr_delta(JAXIS)/2.0
220 j = gr_blkCornerID(JAXIS)-gr_guard(JAXIS)-1
221 do i = gr_jloGc,gr_jhiGc
222 gr_jCoords(LEFT_EDGE,i,1) = gr_jmin+j*gr_delta(JAXIS)
223 gr_jCoords(CENTER,i,1) = gr_jmin+j*gr_delta(JAXIS)+halfDelta
224 j = j+1
225 gr_jCoords(RIGHT_EDGE,i,1) = gr_jmin+j*gr_delta(JAXIS)
226 end do
227 if(gr_axisMe(JAXIS)/=0)gr_blkBC(LOW,JAXIS)=NOT_BOUNDARY
228 if(gr_axisMe(JAXIS)/=(gr_axisNumProcs(JAXIS)-1))&
229 gr_blkBC(HIGH,JAXIS)=NOT_BOUNDARY
230 else
231 gr_jCoords(LEFT_EDGE:RIGHT_EDGE,1,1)=gr_jmin
232 gr_delta(JAXIS)=0.0
233 end if
234
235 if(NDIM > 2) then
236 gr_delta(KAXIS) = (gr_kmax-gr_kmin)/gr_gIndexSize(KAXIS)
237 halfDelta = gr_delta(KAXIS)/2.0
238 j = gr_blkCornerID(KAXIS)-gr_guard(KAXIS)-1
239 do i = gr_kloGc,gr_khiGc
240 gr_kCoords(LEFT_EDGE,i,1) = gr_kmin+j*gr_delta(KAXIS)
241 gr_kCoords(CENTER,i,1) = gr_kmin+j*gr_delta(KAXIS)+halfDelta
242 j = j+1
243 gr_kCoords(RIGHT_EDGE,i,1) = gr_kmin+j*gr_delta(KAXIS)
244 end do
245 if(gr_axisMe(KAXIS)/=0)gr_blkBC(LOW,KAXIS)=NOT_BOUNDARY
246 if(gr_axisMe(KAXIS)/=(gr_axisNumProcs(KAXIS)-1))&
247 gr_blkBC(HIGH,KAXIS)=NOT_BOUNDARY
248 else
249 gr_kCoords(LEFT_EDGE:RIGHT_EDGE,1,1) = gr_kmin
250 gr_delta(KAXIS)=0.0
251 end if
252
253
254end subroutine gr_createDomain
Note: See TracBrowser for help on using the repository browser.