source: CIVL/examples/mpi-omp/AMG2013/sstruct_mv/HYPRE_sstruct_grid.c@ 7d77e64

main test-branch
Last change on this file since 7d77e64 was ea777aa, checked in by Alex Wilton <awilton@…>, 3 years ago

Moved examples, include, build_default.properties, common.xml, and README out from dev.civl.com into the root of the repo.

git-svn-id: ​svn://vsl.cis.udel.edu/civl/trunk@5704 fb995dde-84ed-4084-dfe6-e5aef3e2452c
  • Property mode set to 100644
File size: 26.3 KB
Line 
1/*BHEADER**********************************************************************
2 * Copyright (c) 2008, Lawrence Livermore National Security, LLC.
3 * Produced at the Lawrence Livermore National Laboratory.
4 * This file is part of HYPRE. See file COPYRIGHT for details.
5 *
6 * HYPRE is free software; you can redistribute it and/or modify it under the
7 * terms of the GNU Lesser General Public License (as published by the Free
8 * Software Foundation) version 2.1 dated February 1999.
9 *
10 * $Revision: 2.4 $
11 ***********************************************************************EHEADER*/
12
13
14
15/******************************************************************************
16 *
17 * HYPRE_SStructGrid interface
18 *
19 *****************************************************************************/
20
21#include "headers.h"
22
23/*--------------------------------------------------------------------------
24 *--------------------------------------------------------------------------*/
25
26int
27HYPRE_SStructGridCreate( MPI_Comm comm,
28 int ndim,
29 int nparts,
30 HYPRE_SStructGrid *grid_ptr )
31{
32 int ierr = 0;
33
34 hypre_SStructGrid *grid;
35 hypre_SStructPGrid **pgrids;
36 hypre_SStructPGrid *pgrid;
37 int *nneighbors;
38 hypre_SStructNeighbor **neighbors;
39 int i;
40
41 grid = hypre_TAlloc(hypre_SStructGrid, 1);
42
43 hypre_SStructGridComm(grid) = comm;
44 hypre_SStructGridNDim(grid) = ndim;
45 hypre_SStructGridNParts(grid) = nparts;
46 pgrids = hypre_TAlloc(hypre_SStructPGrid *, nparts);
47 nneighbors = hypre_TAlloc(int, nparts);
48 neighbors = hypre_TAlloc(hypre_SStructNeighbor *, nparts);
49 for (i = 0; i < nparts; i++)
50 {
51 hypre_SStructPGridCreate(comm, ndim, &pgrid);
52 pgrids[i] = pgrid;
53 nneighbors[i] = 0;
54 neighbors[i] = NULL;
55 }
56 hypre_SStructGridPGrids(grid) = pgrids;
57 hypre_SStructGridNNeighbors(grid) = nneighbors;
58 hypre_SStructGridNeighbors(grid) = neighbors;
59 hypre_SStructGridNUCVars(grid) = 0;
60 hypre_SStructGridUCVars(grid) = NULL;
61
62 hypre_SStructGridMaps(grid) = NULL;
63 hypre_SStructGridInfo(grid) = NULL;
64
65 /* miscellaneous */
66 hypre_SStructGridLocalSize(grid) = 0;
67 hypre_SStructGridGlobalSize(grid) = 0;
68 hypre_SStructGridRefCount(grid) = 1;
69
70 /* GEC0902 ghost addition to the grid */
71 hypre_SStructGridGhlocalSize(grid) = 0;
72
73 *grid_ptr = grid;
74
75 return ierr;
76}
77
78/*--------------------------------------------------------------------------
79 *--------------------------------------------------------------------------*/
80
81int
82HYPRE_SStructGridDestroy( HYPRE_SStructGrid grid )
83{
84 int ierr = 0;
85
86 int nparts;
87 hypre_SStructPGrid **pgrids;
88 int *nneighbors;
89 hypre_SStructNeighbor **neighbors;
90 int **nvneighbors;
91 hypre_SStructNeighbor ***vneighbors;
92 hypre_BoxMap ***maps;
93 hypre_SStructMapInfo ***info;
94 hypre_SStructNMapInfo ***ninfo;
95 int nvars;
96 int part, var;
97
98 if (grid)
99 {
100 hypre_SStructGridRefCount(grid) --;
101 if (hypre_SStructGridRefCount(grid) == 0)
102 {
103 nparts = hypre_SStructGridNParts(grid);
104 pgrids = hypre_SStructGridPGrids(grid);
105 nneighbors = hypre_SStructGridNNeighbors(grid);
106 neighbors = hypre_SStructGridNeighbors(grid);
107 nvneighbors = hypre_SStructGridNVNeighbors(grid);
108 vneighbors = hypre_SStructGridVNeighbors(grid);
109 maps = hypre_SStructGridMaps(grid);
110 info = hypre_SStructGridInfo(grid);
111 ninfo = hypre_SStructGridNInfo(grid);
112 for (part = 0; part < nparts; part++)
113 {
114 nvars = hypre_SStructPGridNVars(pgrids[part]);
115 for (var = 0; var < nvars; var++)
116 {
117 hypre_TFree(vneighbors[part][var]);
118 hypre_BoxMapDestroy(maps[part][var]);
119 hypre_TFree(info[part][var]);
120 hypre_TFree(ninfo[part][var]);
121 }
122 hypre_TFree(neighbors[part]);
123 hypre_TFree(nvneighbors[part]);
124 hypre_TFree(vneighbors[part]);
125 hypre_SStructPGridDestroy(pgrids[part]);
126 hypre_TFree(maps[part]);
127 hypre_TFree(info[part]);
128 hypre_TFree(ninfo[part]);
129 }
130 hypre_TFree(pgrids);
131 hypre_TFree(nneighbors);
132 hypre_TFree(neighbors);
133 hypre_TFree(nvneighbors);
134 hypre_TFree(vneighbors);
135 hypre_TFree(maps);
136 hypre_TFree(info);
137 hypre_TFree(ninfo);
138 hypre_TFree(grid);
139 }
140 }
141
142 return ierr;
143}
144
145/*--------------------------------------------------------------------------
146 *--------------------------------------------------------------------------*/
147
148int
149HYPRE_SStructGridSetExtents( HYPRE_SStructGrid grid,
150 int part,
151 int *ilower,
152 int *iupper )
153{
154 int ndim = hypre_SStructGridNDim(grid);
155 hypre_SStructPGrid *pgrid = hypre_SStructGridPGrid(grid, part);
156 hypre_Index cilower;
157 hypre_Index ciupper;
158
159 hypre_CopyToCleanIndex(ilower, ndim, cilower);
160 hypre_CopyToCleanIndex(iupper, ndim, ciupper);
161
162 return ( hypre_SStructPGridSetExtents(pgrid, cilower, ciupper) );
163}
164
165/*--------------------------------------------------------------------------
166 *--------------------------------------------------------------------------*/
167
168int HYPRE_SStructGridSetVariables( HYPRE_SStructGrid grid,
169 int part,
170 int nvars,
171 HYPRE_SStructVariable *vartypes )
172{
173 hypre_SStructPGrid *pgrid = hypre_SStructGridPGrid(grid, part);
174
175 return ( hypre_SStructPGridSetVariables(pgrid, nvars, vartypes) );
176}
177
178/*--------------------------------------------------------------------------
179 * HYPRE_SStructGridSetVariable
180 * Like HYPRE_SStructGridSetVariables, but do one variable at a time.
181 * Nevertheless, you still must provide nvars, for memory allocation.
182 *--------------------------------------------------------------------------*/
183
184int HYPRE_SStructGridSetVariable( HYPRE_SStructGrid grid,
185 int part,
186 int var,
187 int nvars,
188 HYPRE_SStructVariable vartype )
189{
190 hypre_SStructPGrid *pgrid = hypre_SStructGridPGrid(grid, part);
191
192 return hypre_SStructPGridSetVariable( pgrid, var, nvars, vartype );
193}
194
195
196/*--------------------------------------------------------------------------
197 *--------------------------------------------------------------------------*/
198
199int
200HYPRE_SStructGridAddVariables( HYPRE_SStructGrid grid,
201 int part,
202 int *index,
203 int nvars,
204 HYPRE_SStructVariable *vartypes )
205{
206 int ierr = 0;
207
208 int ndim = hypre_SStructGridNDim(grid);
209 int nucvars = hypre_SStructGridNUCVars(grid);
210 hypre_SStructUCVar **ucvars = hypre_SStructGridUCVars(grid);
211 hypre_SStructUCVar *ucvar;
212
213 int memchunk = 1000;
214 int i;
215
216 /* allocate more space if necessary */
217 if ((nucvars % memchunk) == 0)
218 {
219 ucvars = hypre_TReAlloc(ucvars, hypre_SStructUCVar *,
220 (nucvars + memchunk));
221 }
222
223 ucvar = hypre_TAlloc(hypre_SStructUCVar, 1);
224 hypre_SStructUCVarUVars(ucvar) = hypre_TAlloc(hypre_SStructUVar, nvars);
225 hypre_SStructUCVarPart(ucvar) = part;
226 hypre_CopyToCleanIndex(index, ndim, hypre_SStructUCVarCell(ucvar));
227 hypre_SStructUCVarNUVars(ucvar) = nvars;
228 for (i = 0; i < nvars; i++)
229 {
230 hypre_SStructUCVarType(ucvar, i) = vartypes[i];
231 hypre_SStructUCVarRank(ucvar, i) = -1; /* don't know, yet */
232 hypre_SStructUCVarProc(ucvar, i) = -1; /* don't know, yet */
233 }
234 ucvars[nucvars] = ucvar;
235 nucvars++;
236
237 hypre_SStructGridNUCVars(grid) = nucvars;
238 hypre_SStructGridUCVars(grid) = ucvars;
239
240 return ierr;
241}
242
243/*--------------------------------------------------------------------------
244 * HYPRE_SStructGridAddVariable
245 * Like HYPRE_SStructGridAddVariables, but just one variable at a time.
246 *--------------------------------------------------------------------------*/
247
248int
249HYPRE_SStructGridAddVariable( HYPRE_SStructGrid grid,
250 int part,
251 int *index,
252 int var,
253 HYPRE_SStructVariable vartype )
254{
255 int ierr = 0;
256
257 int ndim = hypre_SStructGridNDim(grid);
258 int nucvars = hypre_SStructGridNUCVars(grid);
259 hypre_SStructUCVar **ucvars = hypre_SStructGridUCVars(grid);
260 hypre_SStructUCVar *ucvar;
261
262 int memchunk = 1000;
263 int nvars = 1; /* each ucvar gets only one variable */
264
265 /* allocate more space if necessary */
266 if ((nucvars % memchunk) == 0)
267 {
268 ucvars = hypre_TReAlloc(ucvars, hypre_SStructUCVar *,
269 (nucvars + memchunk));
270 }
271
272 ucvar = hypre_TAlloc(hypre_SStructUCVar, 1);
273 hypre_SStructUCVarUVars(ucvar) = hypre_TAlloc(hypre_SStructUVar, nvars);
274 hypre_SStructUCVarPart(ucvar) = part;
275 hypre_CopyToCleanIndex(index, ndim, hypre_SStructUCVarCell(ucvar));
276 hypre_SStructUCVarNUVars(ucvar) = nvars;
277
278 hypre_SStructUCVarType(ucvar, var) = vartype;
279 hypre_SStructUCVarRank(ucvar, var) = -1; /* don't know, yet */
280 hypre_SStructUCVarProc(ucvar, var) = -1; /* don't know, yet */
281
282 ucvars[nucvars] = ucvar;
283 nucvars++;
284
285 hypre_SStructGridNUCVars(grid) = nucvars;
286 hypre_SStructGridUCVars(grid) = ucvars;
287
288 return ierr;
289}
290
291/*--------------------------------------------------------------------------
292 *--------------------------------------------------------------------------*/
293
294int
295HYPRE_SStructGridSetNeighborBox( HYPRE_SStructGrid grid,
296 int part,
297 int *ilower,
298 int *iupper,
299 int nbor_part,
300 int *nbor_ilower,
301 int *nbor_iupper,
302 int *index_map )
303{
304 int ierr = 0;
305
306 int ndim = hypre_SStructGridNDim(grid);
307 int *nneighbors = hypre_SStructGridNNeighbors(grid);
308 hypre_SStructNeighbor **neighbors = hypre_SStructGridNeighbors(grid);
309 hypre_SStructNeighbor *neighbor;
310
311 hypre_Box *box;
312 hypre_Index cilower;
313 hypre_Index ciupper;
314 int memchunk = 10;
315 int d;
316
317 /* allocate more memory if needed */
318 if ((nneighbors[part] % memchunk) == 0)
319 {
320 neighbors[part] = hypre_TReAlloc(neighbors[part], hypre_SStructNeighbor,
321 (nneighbors[part] + memchunk));
322 }
323
324 neighbor = &neighbors[part][nneighbors[part]];
325 nneighbors[part]++;
326
327 box = hypre_SStructNeighborBox(neighbor);
328 hypre_CopyToCleanIndex(ilower, ndim, cilower);
329 hypre_CopyToCleanIndex(iupper, ndim, ciupper);
330 hypre_BoxSetExtents(box, cilower, ciupper);
331
332 hypre_SStructNeighborPart(neighbor) = nbor_part;
333
334 hypre_CopyToCleanIndex(nbor_ilower, ndim,
335 hypre_SStructNeighborILower(neighbor));
336
337 hypre_CopyIndex(index_map, hypre_SStructNeighborCoord(neighbor));
338 for (d = ndim; d < 3; d++)
339 {
340 hypre_IndexD(hypre_SStructNeighborCoord(neighbor), d) = d;
341 }
342
343 for (d = 0; d < 3; d++)
344 {
345 hypre_IndexD(hypre_SStructNeighborDir(neighbor), d) = 1;
346
347 if (d < ndim)
348 {
349 if (hypre_IndexD(nbor_ilower, d) > hypre_IndexD(nbor_iupper, d))
350 {
351 hypre_IndexD(hypre_SStructNeighborDir(neighbor), d) = -1;
352 }
353 }
354 }
355
356 /* part with the smaller ID owns the primary variables */
357 if (part < nbor_part)
358 {
359 hypre_SStructNeighborPrimary(neighbor) = 1;
360 }
361 else
362 {
363 hypre_SStructNeighborPrimary(neighbor) = 0;
364 }
365
366 return ierr;
367}
368
369/*--------------------------------------------------------------------------
370 * ** TEMPORARY **
371 *--------------------------------------------------------------------------*/
372
373int
374HYPRE_SStructGridSetNeighborBoxZ( HYPRE_SStructGrid grid,
375 int part,
376 int *ilower,
377 int *iupper,
378 int nbor_part,
379 int *nbor_ilower,
380 int *nbor_iupper,
381 int *index_map,
382 int primary )
383{
384 int ierr = 0;
385
386 int ndim = hypre_SStructGridNDim(grid);
387 int *nneighbors = hypre_SStructGridNNeighbors(grid);
388 hypre_SStructNeighbor **neighbors = hypre_SStructGridNeighbors(grid);
389 hypre_SStructNeighbor *neighbor;
390
391 hypre_Box *box;
392 hypre_Index cilower;
393 hypre_Index ciupper;
394 int memchunk = 10;
395 int d;
396
397 /* allocate more memory if needed */
398 if ((nneighbors[part] % memchunk) == 0)
399 {
400 neighbors[part] = hypre_TReAlloc(neighbors[part], hypre_SStructNeighbor,
401 (nneighbors[part] + memchunk));
402 }
403
404 neighbor = &neighbors[part][nneighbors[part]];
405 nneighbors[part]++;
406
407 box = hypre_SStructNeighborBox(neighbor);
408 hypre_CopyToCleanIndex(ilower, ndim, cilower);
409 hypre_CopyToCleanIndex(iupper, ndim, ciupper);
410 hypre_BoxSetExtents(box, cilower, ciupper);
411
412 hypre_SStructNeighborPart(neighbor) = nbor_part;
413
414 hypre_CopyToCleanIndex(nbor_ilower, ndim,
415 hypre_SStructNeighborILower(neighbor));
416
417 hypre_CopyIndex(index_map, hypre_SStructNeighborCoord(neighbor));
418 for (d = ndim; d < 3; d++)
419 {
420 hypre_IndexD(hypre_SStructNeighborCoord(neighbor), d) = d;
421 }
422
423 for (d = 0; d < 3; d++)
424 {
425 hypre_IndexD(hypre_SStructNeighborDir(neighbor), d) = 1;
426
427 if (d < ndim)
428 {
429 if (hypre_IndexD(nbor_ilower, d) > hypre_IndexD(nbor_iupper, d))
430 {
431 hypre_IndexD(hypre_SStructNeighborDir(neighbor), d) = -1;
432 }
433 }
434 }
435
436 if (primary < 0)
437 {
438 /* hypre decides: part with the smaller ID owns the primary variables */
439 if (part < nbor_part)
440 {
441 primary = 1;
442 }
443 else
444 {
445 primary = 0;
446 }
447 }
448 hypre_SStructNeighborPrimary(neighbor) = primary;
449
450 return ierr;
451}
452
453/*--------------------------------------------------------------------------
454 * *** placeholder ***
455 *--------------------------------------------------------------------------*/
456
457#if 0
458int
459HYPRE_SStructGridAddUnstructuredPart( HYPRE_SStructGrid grid,
460 int ilower,
461 int iupper )
462{
463 return ( hypre_SStructGridAssemble(grid) );
464}
465#endif
466
467/*--------------------------------------------------------------------------
468 *--------------------------------------------------------------------------*/
469
470int
471HYPRE_SStructGridAssemble( HYPRE_SStructGrid grid )
472{
473 int ierr = 0;
474
475 int ndim = hypre_SStructGridNDim(grid);
476 int nparts = hypre_SStructGridNParts(grid);
477 hypre_SStructPGrid **pgrids = hypre_SStructGridPGrids(grid);
478 int *nneighbors = hypre_SStructGridNNeighbors(grid);
479 hypre_SStructNeighbor **neighbors = hypre_SStructGridNeighbors(grid);
480 int **nvneighbors = hypre_SStructGridNVNeighbors(grid);
481 hypre_SStructNeighbor ***vneighbors = hypre_SStructGridVNeighbors(grid);
482 hypre_SStructNeighbor *neighbor;
483 hypre_SStructNeighbor *vneighbor;
484 hypre_BoxArrayArray *nbor_boxes;
485 hypre_BoxArray *nbor_boxa;
486 hypre_Box *nbor_box;
487 hypre_BoxArray *sub_boxa;
488 hypre_BoxArray *tmp_boxa;
489 hypre_Box *map_box;
490 hypre_Box *int_box;
491 hypre_BoxMapEntry **entries;
492 int nentries;
493 int *ilower, *imin0, *imin1, *coord, *dir;
494
495 hypre_SStructPGrid *pgrid;
496 HYPRE_SStructVariable *vartypes;
497 hypre_Index varoffset;
498 int nvars;
499 int part, npart, var, i, b, vb, t, d, nd;
500
501 /*-------------------------------------------------------------
502 * set pneighbors for each pgrid info to crop pgrids
503 *-------------------------------------------------------------*/
504
505 /*
506 * ZTODO: Note that if neighbor boxes are not first intersected with
507 * the global grid, then local pgrid info may be incorrectly cropped.
508 * This would occur if users pass in neighbor extents that do not
509 * actually live anywhere on the global grid.
510 *
511 * This is not an issue for cell-centered variables.
512 */
513
514 for (part = 0; part < nparts; part++)
515 {
516 pgrid = hypre_SStructGridPGrid(grid, part);
517 for (i = 0; i < nneighbors[part]; i++)
518 {
519 neighbor = &neighbors[part][i];
520
521 if (!hypre_SStructNeighborPrimary(neighbor))
522 {
523 hypre_SStructPGridSetPNeighbor(pgrid,
524 hypre_SStructNeighborBox(neighbor));
525 }
526 }
527 }
528
529 /*-------------------------------------------------------------
530 * assemble the pgrids
531 *-------------------------------------------------------------*/
532
533 for (part = 0; part < nparts; part++)
534 {
535 hypre_SStructPGridAssemble(pgrids[part]);
536 }
537
538 /*-------------------------------------------------------------
539 * re-organize u-variables to reference via local cell rank
540 *-------------------------------------------------------------*/
541
542 /* TODO */
543
544 /*-------------------------------------------------------------
545 * determine a unique u-variable data distribution
546 *-------------------------------------------------------------*/
547
548 /* TODO */
549
550 /*-------------------------------------------------------------
551 * set up the size info
552 * GEC0902 calculation of the local ghost size for grid
553 *-------------------------------------------------------------*/
554
555 for (part = 0; part < nparts; part++)
556 {
557 pgrid = hypre_SStructGridPGrid(grid, part);
558 hypre_SStructGridLocalSize(grid) += hypre_SStructPGridLocalSize(pgrid);
559 hypre_SStructGridGlobalSize(grid) += hypre_SStructPGridGlobalSize(pgrid);
560 hypre_SStructGridGhlocalSize(grid) += hypre_SStructPGridGhlocalSize(pgrid);
561 }
562
563 /*-------------------------------------------------
564 * Assemble the map info
565 *-------------------------------------------------*/
566
567 hypre_SStructGridAssembleMaps(grid);
568
569 /*-------------------------------------------------
570 * Set up neighbor info
571 *
572 * ZTODO: This should work for all variable types,
573 * but it has only been tested for cell-centered.
574 *-------------------------------------------------*/
575
576 nbor_box = hypre_BoxCreate();
577 map_box = hypre_BoxCreate();
578 int_box = hypre_BoxCreate();
579
580 nvneighbors = hypre_TAlloc(int *, nparts);
581 vneighbors = hypre_TAlloc(hypre_SStructNeighbor **, nparts);
582
583 for (part = 0; part < nparts; part++)
584 {
585 pgrid = hypre_SStructGridPGrid(grid, part);
586 nvars = hypre_SStructPGridNVars(pgrid);
587 vartypes = hypre_SStructPGridVarTypes(pgrid);
588 nvneighbors[part] = hypre_TAlloc(int, nvars);
589 vneighbors[part] = hypre_TAlloc(hypre_SStructNeighbor *, nvars);
590
591 nbor_boxes = hypre_BoxArrayArrayCreate(nneighbors[part]);
592 for (var = 0; var < nvars; var++)
593 {
594 t = vartypes[var];
595 hypre_SStructVariableGetOffset((hypre_SStructVariable) t,
596 ndim, varoffset);
597
598 /* Intersect neighbor boxes with appropriate PGrid */
599 for (b = 0; b < nneighbors[part]; b++)
600 {
601 neighbor = &neighbors[part][b];
602 nbor_boxa = hypre_BoxArrayArrayBoxArray(nbor_boxes, b);
603 hypre_BoxArraySetSize(nbor_boxa, 0);
604
605 imin0 = hypre_BoxIMin(hypre_SStructNeighborBox(neighbor));
606 imin1 = hypre_SStructNeighborILower(neighbor);
607 coord = hypre_SStructNeighborCoord(neighbor);
608 dir = hypre_SStructNeighborDir(neighbor);
609
610 hypre_CopyBox(hypre_SStructNeighborBox(neighbor), nbor_box);
611 hypre_BoxIMinX(nbor_box) -= hypre_IndexX(varoffset);
612 hypre_BoxIMinY(nbor_box) -= hypre_IndexY(varoffset);
613 hypre_BoxIMinZ(nbor_box) -= hypre_IndexZ(varoffset);
614
615 /* map to neighbor part index space */
616 hypre_SStructBoxToNBorBox(nbor_box, imin0, imin1, coord, dir);
617
618 npart = hypre_SStructNeighborPart(neighbor);
619 hypre_BoxMapIntersect(hypre_SStructGridMap(grid, npart, var),
620 hypre_BoxIMin(nbor_box),
621 hypre_BoxIMax(nbor_box),
622 &entries, &nentries );
623
624 for (i = 0; i < nentries; i++)
625 {
626 hypre_BoxMapEntryGetExtents(entries[i],
627 hypre_BoxIMin(map_box),
628 hypre_BoxIMax(map_box));
629
630 hypre_IntersectBoxes(nbor_box, map_box, int_box);
631 if (hypre_BoxVolume(int_box))
632 {
633 /* map back from neighbor part index space */
634 hypre_SStructNBorBoxToBox(int_box, imin0, imin1, coord, dir);
635
636 hypre_AppendBox(int_box, nbor_boxa);
637 }
638 }
639 hypre_TFree(entries);
640 }
641
642 /* Make sure that the neighbor boxes don't overlap */
643 tmp_boxa = hypre_BoxArrayCreate(0);
644 for (b = 0; b < nneighbors[part]; b++)
645 {
646 nbor_boxa = hypre_BoxArrayArrayBoxArray(nbor_boxes, b);
647 for (i = 0; i < b; i++)
648 {
649 sub_boxa = hypre_BoxArrayArrayBoxArray(nbor_boxes, i);
650 hypre_SubtractBoxArrays(nbor_boxa, sub_boxa, tmp_boxa);
651 }
652 }
653 hypre_BoxArrayDestroy(tmp_boxa);
654
655 /* Compute new number of vneighbors, nvneighbors */
656 nvneighbors[part][var] = 0;
657 for (b = 0; b < nneighbors[part]; b++)
658 {
659 nbor_boxa = hypre_BoxArrayArrayBoxArray(nbor_boxes, b);
660 nvneighbors[part][var] += hypre_BoxArraySize(nbor_boxa);
661 }
662
663 /* Set up vneighbors */
664 vneighbors[part][var] =
665 hypre_TAlloc(hypre_SStructNeighbor, nvneighbors[part][var]);
666 vb = 0;
667 for (b = 0; b < nneighbors[part]; b++)
668 {
669 neighbor = &neighbors[part][b];
670 nbor_boxa = hypre_BoxArrayArrayBoxArray(nbor_boxes, b);
671
672 hypre_ForBoxI(i, nbor_boxa)
673 {
674 vneighbor = &vneighbors[part][var][vb];
675
676 hypre_CopyBox(hypre_BoxArrayBox(nbor_boxa, i),
677 hypre_SStructNeighborBox(vneighbor));
678 hypre_SStructNeighborPart(vneighbor) =
679 hypre_SStructNeighborPart(neighbor);
680 hypre_CopyIndex(hypre_SStructNeighborILower(neighbor),
681 hypre_SStructNeighborILower(vneighbor));
682 hypre_CopyIndex(hypre_SStructNeighborCoord(neighbor),
683 hypre_SStructNeighborCoord(vneighbor));
684 hypre_CopyIndex(hypre_SStructNeighborDir(neighbor),
685 hypre_SStructNeighborDir(vneighbor));
686
687 /* adjust vneighbor ilower appropriately */
688 ilower = hypre_SStructNeighborILower(vneighbor);
689 imin0 = hypre_BoxIMin(hypre_SStructNeighborBox(neighbor));
690 imin1 = hypre_BoxIMin(hypre_SStructNeighborBox(vneighbor));
691 coord = hypre_SStructNeighborCoord(vneighbor);
692 dir = hypre_SStructNeighborDir(vneighbor);
693 for (d = 0; d < 3; d++)
694 {
695 nd = coord[d];
696 ilower[nd] += (imin1[d] - imin0[d]) * dir[nd];
697 }
698
699 vb++;
700 }
701 }
702 }
703
704 hypre_BoxArrayArrayDestroy(nbor_boxes);
705 }
706
707 hypre_SStructGridNVNeighbors(grid) = nvneighbors;
708 hypre_SStructGridVNeighbors(grid) = vneighbors;
709
710 hypre_BoxDestroy(nbor_box);
711 hypre_BoxDestroy(map_box);
712 hypre_BoxDestroy(int_box);
713
714 /*-------------------------------------------------
715 * Assemble the neighbor map info
716 *-------------------------------------------------*/
717
718 hypre_SStructGridAssembleNBorMaps(grid);
719
720 return ierr;
721}
722
723/*--------------------------------------------------------------------------
724 *--------------------------------------------------------------------------*/
725
726int
727HYPRE_SStructGridSetPeriodic( HYPRE_SStructGrid grid,
728 int part,
729 int *periodic )
730{
731 int ierr = 0;
732
733 hypre_SStructPGrid *pgrid = hypre_SStructGridPGrid(grid, part);
734 hypre_IndexRef pgrid_periodic = hypre_SStructPGridPeriodic(pgrid);
735 int d;
736
737 for (d = 0; d < hypre_SStructGridNDim(grid); d++)
738 {
739 hypre_IndexD(pgrid_periodic, d) = periodic[d];
740 }
741
742 return ierr;
743}
744
745
746/*--------------------------------------------------------------------------
747 * GEC0902 a placeholder for a internal function that will set ghosts in each
748 * of the sgrids of the grid
749 *
750 *--------------------------------------------------------------------------*/
751int
752HYPRE_SStructGridSetNumGhost( HYPRE_SStructGrid grid,
753 int *num_ghost)
754{
755 return ( hypre_SStructGridSetNumGhost(grid, num_ghost) );
756}
Note: See TracBrowser for help on using the repository browser.