int
HYPRE_StructVectorSetBoxValues( HYPRE_StructVector vector,
int *ilower,
int *iupper,
double *values )
{
hypre_Index new_ilower;
hypre_Index new_iupper;
hypre_Box *new_value_box;
int d;
int ierr = 0;
hypre_ClearIndex(new_ilower);
hypre_ClearIndex(new_iupper);
for (d = 0; d < hypre_StructGridDim(hypre_StructVectorGrid(vector)); d++)
{
hypre_IndexD(new_ilower, d) = ilower[d];
hypre_IndexD(new_iupper, d) = iupper[d];
}
new_value_box = hypre_BoxCreate();
hypre_BoxSetExtents(new_value_box, new_ilower, new_iupper);
ierr = hypre_StructVectorSetBoxValues(vector, new_value_box, values, 0 );
hypre_BoxDestroy(new_value_box);
return ierr;
}
int
HYPRE_StructMatrixSetBoxValues( HYPRE_StructMatrix matrix,
int *ilower,
int *iupper,
int num_stencil_indices,
int *stencil_indices,
double *values )
{
hypre_Index new_ilower;
hypre_Index new_iupper;
hypre_Box *new_value_box;
int d;
int ierr = 0;
hypre_ClearIndex(new_ilower);
hypre_ClearIndex(new_iupper);
for (d = 0; d < hypre_StructGridDim(hypre_StructMatrixGrid(matrix)); d++)
{
hypre_IndexD(new_ilower, d) = ilower[d];
hypre_IndexD(new_iupper, d) = iupper[d];
}
new_value_box = hypre_BoxCreate();
hypre_BoxSetExtents(new_value_box, new_ilower, new_iupper);
ierr = hypre_StructMatrixSetBoxValues(matrix, new_value_box,
num_stencil_indices, stencil_indices,
values, 0);
hypre_BoxDestroy(new_value_box);
return (ierr);
}
int
HYPRE_StructGridSetExtents( HYPRE_StructGrid grid,
int *ilower,
int *iupper )
{
hypre_Index new_ilower;
hypre_Index new_iupper;
int d;
hypre_ClearIndex(new_ilower);
hypre_ClearIndex(new_iupper);
for (d = 0; d < hypre_StructGridDim((hypre_StructGrid *) grid); d++)
{
hypre_IndexD(new_ilower, d) = ilower[d];
hypre_IndexD(new_iupper, d) = iupper[d];
}
return ( hypre_StructGridSetExtents(grid, new_ilower, new_iupper) );
}
int
HYPRE_StructGridSetPeriodic( HYPRE_StructGrid grid,
int *periodic )
{
hypre_Index new_periodic;
int d;
hypre_ClearIndex(new_periodic);
for (d = 0; d < hypre_StructGridDim(grid); d++)
{
hypre_IndexD(new_periodic, d) = periodic[d];
}
return ( hypre_StructGridSetPeriodic(grid, new_periodic) );
}
int
HYPRE_StructStencilSetElement( HYPRE_StructStencil stencil,
int element_index,
int *offset )
{
int ierr = 0;
hypre_Index *shape;
int d;
shape = hypre_StructStencilShape(stencil);
hypre_ClearIndex(shape[element_index]);
for (d = 0; d < hypre_StructStencilDim(stencil); d++)
{
hypre_IndexD(shape[element_index], d) = offset[d];
}
return ierr;
}
HYPRE_Int
HYPRE_StructVectorSetValues( HYPRE_StructVector vector,
HYPRE_Int *grid_index,
double values )
{
hypre_Index new_grid_index;
HYPRE_Int d;
hypre_ClearIndex(new_grid_index);
for (d = 0; d < hypre_StructGridDim(hypre_StructVectorGrid(vector)); d++)
{
hypre_IndexD(new_grid_index, d) = grid_index[d];
}
hypre_StructVectorSetValues(vector, new_grid_index, &values, 0, -1, 0);
return hypre_error_flag;
}
int
HYPRE_StructVectorSetValues( HYPRE_StructVector vector,
int *grid_index,
double values )
{
hypre_Index new_grid_index;
int d;
int ierr = 0;
hypre_ClearIndex(new_grid_index);
for (d = 0; d < hypre_StructGridDim(hypre_StructVectorGrid(vector)); d++)
{
hypre_IndexD(new_grid_index, d) = grid_index[d];
}
ierr = hypre_StructVectorSetValues(vector, new_grid_index, values, 0);
return ierr;
}
int
HYPRE_StructMatrixSetValues( HYPRE_StructMatrix matrix,
int *grid_index,
int num_stencil_indices,
int *stencil_indices,
double *values )
{
hypre_Index new_grid_index;
int d;
int ierr = 0;
hypre_ClearIndex(new_grid_index);
for (d = 0; d < hypre_StructGridDim(hypre_StructMatrixGrid(matrix)); d++)
{
hypre_IndexD(new_grid_index, d) = grid_index[d];
}
ierr = hypre_StructMatrixSetValues(matrix, new_grid_index,
num_stencil_indices, stencil_indices,
values, 0);
return (ierr);
}
hypre_SStructSendInfoData *
hypre_SStructSendInfo( hypre_StructGrid *fgrid,
hypre_BoxManager *cboxman,
hypre_Index rfactor )
{
hypre_SStructSendInfoData *sendinfo_data;
MPI_Comm comm= hypre_SStructVectorComm(fgrid);
hypre_BoxArray *grid_boxes;
hypre_Box *grid_box, cbox;
hypre_Box *intersect_box, boxman_entry_box;
hypre_BoxManEntry **boxman_entries;
HYPRE_Int nboxman_entries;
hypre_BoxArrayArray *send_boxes;
HYPRE_Int **send_processes;
HYPRE_Int **send_remote_boxnums;
hypre_Index ilower, iupper, index;
HYPRE_Int myproc, proc;
HYPRE_Int cnt;
HYPRE_Int i, j;
hypre_ClearIndex(index);
hypre_MPI_Comm_rank(comm, &myproc);
sendinfo_data= hypre_CTAlloc(hypre_SStructSendInfoData, 1);
/*------------------------------------------------------------------------
* Create the structured sendbox patterns.
*
* send_boxes are obtained by intersecting this proc's fgrid boxes
* with cgrid's box_man. Intersecting BoxManEntries not on this proc
* will give boxes that we will need to send data to- i.e., we scan
* through the boxes of grid and find the processors that own a chunk
* of it.
*------------------------------------------------------------------------*/
intersect_box = hypre_CTAlloc(hypre_Box, 1);
grid_boxes = hypre_StructGridBoxes(fgrid);
send_boxes= hypre_BoxArrayArrayCreate(hypre_BoxArraySize(grid_boxes));
send_processes= hypre_CTAlloc(HYPRE_Int *, hypre_BoxArraySize(grid_boxes));
send_remote_boxnums= hypre_CTAlloc(HYPRE_Int *, hypre_BoxArraySize(grid_boxes));
hypre_ForBoxI(i, grid_boxes)
{
grid_box= hypre_BoxArrayBox(grid_boxes, i);
/*---------------------------------------------------------------------
* Find the boxarray that must be sent. BoxManIntersect returns
* the full extents of the boxes that intersect with the given box.
* We further need to intersect each box in the list with the given
* box to determine the actual box that needs to be sent.
*---------------------------------------------------------------------*/
hypre_SStructIndexScaleF_C(hypre_BoxIMin(grid_box), index,
rfactor, hypre_BoxIMin(&cbox));
hypre_SStructIndexScaleF_C(hypre_BoxIMax(grid_box), index,
rfactor, hypre_BoxIMax(&cbox));
hypre_BoxManIntersect(cboxman, hypre_BoxIMin(&cbox), hypre_BoxIMax(&cbox),
&boxman_entries, &nboxman_entries);
cnt= 0;
for (j= 0; j< nboxman_entries; j++)
{
hypre_SStructBoxManEntryGetProcess(boxman_entries[j], &proc);
if (proc != myproc)
{
cnt++;
}
}
send_processes[i] = hypre_CTAlloc(HYPRE_Int, cnt);
send_remote_boxnums[i]= hypre_CTAlloc(HYPRE_Int, cnt);
cnt= 0;
for (j= 0; j< nboxman_entries; j++)
{
hypre_SStructBoxManEntryGetProcess(boxman_entries[j], &proc);
/* determine the chunk of the boxman_entries[j] box that is needed */
hypre_BoxManEntryGetExtents(boxman_entries[j], ilower, iupper);
hypre_BoxSetExtents(&boxman_entry_box, ilower, iupper);
hypre_IntersectBoxes(&boxman_entry_box, &cbox, &boxman_entry_box);
if (proc != myproc)
{
send_processes[i][cnt] = proc;
hypre_SStructBoxManEntryGetBoxnum(boxman_entries[j],
&send_remote_boxnums[i][cnt]);
hypre_AppendBox(&boxman_entry_box,
hypre_BoxArrayArrayBoxArray(send_boxes, i));
cnt++;
}
}
hypre_TFree(boxman_entries);
} /* hypre_ForBoxI(i, grid_boxes) */
HYPRE_Int
hypre_FacSemiRestrictSetup2( void *fac_restrict_vdata,
hypre_SStructVector *r,
HYPRE_Int part_crse,
HYPRE_Int part_fine,
hypre_SStructPVector *rc,
hypre_Index rfactors )
{
HYPRE_Int ierr = 0;
hypre_FacSemiRestrictData2 *fac_restrict_data = fac_restrict_vdata;
MPI_Comm comm= hypre_SStructPVectorComm(rc);
hypre_CommInfo *comm_info;
hypre_CommPkg **interlevel_comm;
hypre_SStructPVector *rf= hypre_SStructVectorPVector(r, part_fine);
hypre_StructVector *s_rc, *s_cvector;
hypre_SStructPGrid *pgrid;
hypre_SStructPVector *fgrid_cvectors;
hypre_SStructPGrid *fgrid_coarsen;
hypre_BoxArrayArray **identity_arrayboxes;
hypre_BoxArrayArray **fullwgt_ownboxes;
hypre_BoxArrayArray **fullwgt_sendboxes;
hypre_BoxArray *boxarray;
hypre_BoxArray *tmp_boxarray, *intersect_boxes;
HYPRE_Int ***own_cboxnums;
hypre_BoxArrayArray **send_boxes, *send_rboxes;
HYPRE_Int ***send_processes;
HYPRE_Int ***send_remote_boxnums;
hypre_BoxArrayArray **recv_boxes, *recv_rboxes;
HYPRE_Int ***recv_processes;
HYPRE_Int ***recv_remote_boxnums;
hypre_BoxManager *boxman;
hypre_BoxManEntry **boxman_entries;
HYPRE_Int nboxman_entries;
hypre_Box box, scaled_box;
hypre_Index zero_index, index, ilower, iupper;
HYPRE_Int ndim= hypre_SStructVectorNDim(r);
HYPRE_Int myproc, proc;
HYPRE_Int nvars, vars;
HYPRE_Int num_values;
HYPRE_Int i, cnt1, cnt2;
HYPRE_Int fi, ci;
hypre_MPI_Comm_rank(comm, &myproc);
hypre_ClearIndex(zero_index);
nvars= hypre_SStructPVectorNVars(rc);
(fac_restrict_data -> nvars)= nvars;
hypre_CopyIndex(rfactors, (fac_restrict_data -> stride));
for (i= ndim; i< 3; i++)
{
rfactors[i]= 1;
}
/* work vector for storing the fullweighted fgrid boxes */
hypre_SStructPGridCreate(hypre_SStructPVectorComm(rf), ndim, &fgrid_coarsen);
pgrid= hypre_SStructPVectorPGrid(rf);
for (vars= 0; vars< nvars; vars++)
{
boxarray= hypre_StructGridBoxes(hypre_SStructPGridSGrid(pgrid, vars));
hypre_ForBoxI(fi, boxarray)
{
hypre_CopyBox(hypre_BoxArrayBox(boxarray, fi), &box);
hypre_StructMapFineToCoarse(hypre_BoxIMin(&box), zero_index,
rfactors, hypre_BoxIMin(&box));
hypre_StructMapFineToCoarse(hypre_BoxIMax(&box), zero_index,
rfactors, hypre_BoxIMax(&box));
hypre_SStructPGridSetExtents(fgrid_coarsen,
hypre_BoxIMin(&box),
hypre_BoxIMax(&box));
}
}
/*--------------------------------------------------------------------------
* hypre_FacZeroCFSten: Zeroes the coarse stencil coefficients that reach
* into an underlying coarsened refinement box.
* Algo: For each cbox
* {
* 1) refine cbox and expand by one in each direction
* 2) boxman_intersect with the fboxman
* 3) loop over intersection boxes to see if stencil
* reaches over.
* }
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_FacZeroCFSten( hypre_SStructPMatrix *Af,
hypre_SStructPMatrix *Ac,
hypre_SStructGrid *grid,
HYPRE_Int fine_part,
hypre_Index rfactors )
{
hypre_BoxManager *fboxman;
hypre_BoxManEntry **boxman_entries;
HYPRE_Int nboxman_entries;
hypre_SStructPGrid *p_cgrid;
hypre_Box fgrid_box;
hypre_StructGrid *cgrid;
hypre_BoxArray *cgrid_boxes;
hypre_Box *cgrid_box;
hypre_Box scaled_box;
hypre_Box *shift_ibox;
hypre_StructMatrix *smatrix;
hypre_StructStencil *stencils;
HYPRE_Int stencil_size;
hypre_Index refine_factors, upper_shift;
hypre_Index stride;
hypre_Index stencil_shape;
hypre_Index zero_index, ilower, iupper;
HYPRE_Int nvars, var1, var2;
HYPRE_Int ndim;
hypre_Box *ac_dbox;
HYPRE_Real *ac_ptr;
hypre_Index loop_size;
HYPRE_Int iac;
HYPRE_Int ci, i, j;
HYPRE_Int abs_shape;
HYPRE_Int ierr = 0;
p_cgrid = hypre_SStructPMatrixPGrid(Ac);
nvars = hypre_SStructPMatrixNVars(Ac);
ndim = hypre_SStructPGridNDim(p_cgrid);
hypre_BoxInit(&fgrid_box, ndim);
hypre_BoxInit(&scaled_box, ndim);
hypre_ClearIndex(zero_index);
hypre_ClearIndex(stride);
hypre_ClearIndex(upper_shift);
for (i= 0; i< ndim; i++)
{
stride[i]= 1;
upper_shift[i]= rfactors[i]-1;
}
hypre_CopyIndex(rfactors, refine_factors);
if (ndim < 3)
{
for (i= ndim; i< 3; i++)
{
refine_factors[i]= 1;
}
}
for (var1= 0; var1< nvars; var1++)
{
cgrid= hypre_SStructPGridSGrid(hypre_SStructPMatrixPGrid(Ac), var1);
cgrid_boxes= hypre_StructGridBoxes(cgrid);
fboxman= hypre_SStructGridBoxManager(grid, fine_part, var1);
/*------------------------------------------------------------------
* For each parent coarse box find all fboxes that may be connected
* through a stencil entry- refine this box, expand it by one
* in each direction, and boxman_intersect with fboxman
*------------------------------------------------------------------*/
hypre_ForBoxI(ci, cgrid_boxes)
{
cgrid_box= hypre_BoxArrayBox(cgrid_boxes, ci);
hypre_StructMapCoarseToFine(hypre_BoxIMin(cgrid_box), zero_index,
refine_factors, hypre_BoxIMin(&scaled_box));
hypre_StructMapCoarseToFine(hypre_BoxIMax(cgrid_box), upper_shift,
refine_factors, hypre_BoxIMax(&scaled_box));
hypre_SubtractIndexes(hypre_BoxIMin(&scaled_box), stride, 3,
hypre_BoxIMin(&scaled_box));
hypre_AddIndexes(hypre_BoxIMax(&scaled_box), stride, 3,
hypre_BoxIMax(&scaled_box));
hypre_BoxManIntersect(fboxman, hypre_BoxIMin(&scaled_box),
hypre_BoxIMax(&scaled_box), &boxman_entries,
&nboxman_entries);
for (var2= 0; var2< nvars; var2++)
{
stencils= hypre_SStructPMatrixSStencil(Ac, var1, var2);
if (stencils != NULL)
{
stencil_size= hypre_StructStencilSize(stencils);
smatrix = hypre_SStructPMatrixSMatrix(Ac, var1, var2);
ac_dbox = hypre_BoxArrayBox(hypre_StructMatrixDataSpace(smatrix),
ci);
/*---------------------------------------------------------
* Find the stencil coefficients that must be zeroed off.
* Loop over all possible boxes.
*---------------------------------------------------------*/
for (i= 0; i< stencil_size; i++)
{
hypre_CopyIndex(hypre_StructStencilElement(stencils, i),
stencil_shape);
AbsStencilShape(stencil_shape, abs_shape);
if (abs_shape) /* non-centre stencils are zeroed */
{
/* look for connecting fboxes that must be zeroed. */
for (j= 0; j< nboxman_entries; j++)
{
hypre_BoxManEntryGetExtents(boxman_entries[j], ilower, iupper);
hypre_BoxSetExtents(&fgrid_box, ilower, iupper);
shift_ibox= hypre_CF_StenBox(&fgrid_box, cgrid_box, stencil_shape,
refine_factors, ndim);
if ( hypre_BoxVolume(shift_ibox) )
{
ac_ptr= hypre_StructMatrixExtractPointerByIndex(smatrix,
ci,
stencil_shape);
hypre_BoxGetSize(shift_ibox, loop_size);
hypre_BoxLoop1Begin(ndim, loop_size,
ac_dbox, hypre_BoxIMin(shift_ibox),
stride, iac);
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel for private(HYPRE_BOX_PRIVATE,iac) HYPRE_SMP_SCHEDULE
#endif
hypre_BoxLoop1For(iac)
{
ac_ptr[iac] = 0.0;
}
hypre_BoxLoop1End(iac);
} /* if ( hypre_BoxVolume(shift_ibox) ) */
hypre_BoxDestroy(shift_ibox);
} /* for (j= 0; j< nboxman_entries; j++) */
} /* if (abs_shape) */
} /* for (i= 0; i< stencil_size; i++) */
} /* if (stencils != NULL) */
} /* for (var2= 0; var2< nvars; var2++) */
hypre_TFree(boxman_entries);
} /* hypre_ForBoxI ci */
HYPRE_Int
hypre_FacZeroCData( void *fac_vdata,
hypre_SStructMatrix *A )
{
hypre_FACData *fac_data = fac_vdata;
hypre_SStructGrid *grid;
hypre_SStructPGrid *p_cgrid;
hypre_StructGrid *cgrid;
hypre_BoxArray *cgrid_boxes;
hypre_Box *cgrid_box;
hypre_BoxManager *fboxman;
hypre_BoxManEntry **boxman_entries;
HYPRE_Int nboxman_entries;
hypre_Box scaled_box;
hypre_Box intersect_box;
hypre_SStructPMatrix *level_pmatrix;
hypre_StructStencil *stencils;
HYPRE_Int stencil_size;
hypre_Index *refine_factors;
hypre_Index temp_index;
hypre_Index ilower, iupper;
HYPRE_Int max_level = fac_data -> max_levels;
HYPRE_Int *level_to_part = fac_data -> level_to_part;
HYPRE_Int ndim = hypre_SStructMatrixNDim(A);
HYPRE_Int part_crse = 0;
HYPRE_Int part_fine = 1;
HYPRE_Int level;
HYPRE_Int nvars, var;
HYPRE_Int ci, i, j, rem, intersect_size;
double *values;
HYPRE_Int ierr = 0;
for (level= max_level; level> 0; level--)
{
level_pmatrix = hypre_SStructMatrixPMatrix(fac_data -> A_level[level], part_crse);
grid = (fac_data -> grid_level[level]);
refine_factors= &(fac_data -> refine_factors[level]);
p_cgrid= hypre_SStructGridPGrid(grid, part_crse);
nvars = hypre_SStructPGridNVars(p_cgrid);
for (var= 0; var< nvars; var++)
{
stencils = hypre_SStructPMatrixSStencil(level_pmatrix, var, var);
stencil_size= hypre_StructStencilSize(stencils);
/*---------------------------------------------------------------------
* For each variable, find the underlying boxes for each coarse box.
*---------------------------------------------------------------------*/
cgrid = hypre_SStructPGridSGrid(p_cgrid, var);
cgrid_boxes = hypre_StructGridBoxes(cgrid);
fboxman = hypre_SStructGridBoxManager(grid, part_fine, var);
hypre_ForBoxI(ci, cgrid_boxes)
{
cgrid_box= hypre_BoxArrayBox(cgrid_boxes, ci);
hypre_ClearIndex(temp_index);
hypre_StructMapCoarseToFine(hypre_BoxIMin(cgrid_box), temp_index,
*refine_factors, hypre_BoxIMin(&scaled_box));
for (i= 0; i< ndim; i++)
{
temp_index[i]= (*refine_factors)[i]-1;
}
hypre_StructMapCoarseToFine(hypre_BoxIMax(cgrid_box), temp_index,
*refine_factors, hypre_BoxIMax(&scaled_box));
hypre_BoxManIntersect(fboxman, hypre_BoxIMin(&scaled_box),
hypre_BoxIMax(&scaled_box), &boxman_entries,
&nboxman_entries);
for (i= 0; i< nboxman_entries; i++)
{
hypre_BoxManEntryGetExtents(boxman_entries[i], ilower, iupper);
hypre_BoxSetExtents(&intersect_box, ilower, iupper);
hypre_IntersectBoxes(&intersect_box, &scaled_box, &intersect_box);
/* adjust the box so that it is divisible by refine_factors */
for (j= 0; j< ndim; j++)
{
rem= hypre_BoxIMin(&intersect_box)[j]%(*refine_factors)[j];
if (rem)
{
hypre_BoxIMin(&intersect_box)[j]+=(*refine_factors)[j] - rem;
}
}
hypre_ClearIndex(temp_index);
hypre_StructMapFineToCoarse(hypre_BoxIMin(&intersect_box), temp_index,
*refine_factors, hypre_BoxIMin(&intersect_box));
hypre_StructMapFineToCoarse(hypre_BoxIMax(&intersect_box), temp_index,
*refine_factors, hypre_BoxIMax(&intersect_box));
intersect_size= hypre_BoxVolume(&intersect_box);
if (intersect_size > 0)
{
/*------------------------------------------------------------
* Coarse underlying box found. Now zero off.
*------------------------------------------------------------*/
values= hypre_CTAlloc(double, intersect_size);
for (j= 0; j< stencil_size; j++)
{
HYPRE_SStructMatrixSetBoxValues(fac_data -> A_level[level],
part_crse,
hypre_BoxIMin(&intersect_box),
hypre_BoxIMax(&intersect_box),
var, 1, &j, values);
HYPRE_SStructMatrixSetBoxValues(A,
level_to_part[level-1],
hypre_BoxIMin(&intersect_box),
hypre_BoxIMax(&intersect_box),
var, 1, &j, values);
}
hypre_TFree(values);
} /* if (intersect_size > 0) */
} /* for (i= 0; i< nboxman_entries; i++) */
hypre_TFree(boxman_entries);
} /* hypre_ForBoxI(ci, cgrid_boxes) */
} /* for (var= 0; var< nvars; var++) */
/*--------------------------------------------------------------------------
* hypre_CFInterfaceExtents: Given a cgrid_box, a fgrid_box, and stencils,
* find the extents of the C/F interface (interface nodes in the C box).
* Boxes corresponding to stencil shifts are stored in the first stencil_size
* boxes, and the union of these are appended to the end of the returned
* box_array.
*--------------------------------------------------------------------------*/
hypre_BoxArray *
hypre_CFInterfaceExtents( hypre_Box *fgrid_box,
hypre_Box *cgrid_box,
hypre_StructStencil *stencils,
hypre_Index rfactors )
{
hypre_BoxArray *stencil_box_extents;
hypre_BoxArray *union_boxes;
hypre_Box *cfine_box;
hypre_Box *box;
hypre_Index stencil_shape, cstart, zero_index, neg_index;
HYPRE_Int stencil_size;
HYPRE_Int abs_stencil;
HYPRE_Int ndim= hypre_StructStencilDim(stencils);
HYPRE_Int i, j;
hypre_ClearIndex(zero_index);
hypre_ClearIndex(neg_index);
for (i= 0; i< ndim; i++)
{
neg_index[i]= -1;
}
hypre_CopyIndex(hypre_BoxIMin(cgrid_box), cstart);
stencil_size = hypre_StructStencilSize(stencils);
stencil_box_extents= hypre_BoxArrayCreate(stencil_size);
union_boxes = hypre_BoxArrayCreate(0);
for (i= 0; i< stencil_size; i++)
{
hypre_CopyIndex(hypre_StructStencilElement(stencils, i), stencil_shape);
AbsStencilShape(stencil_shape, abs_stencil);
if (abs_stencil) /* only do if not the centre stencil */
{
cfine_box= hypre_CF_StenBox(fgrid_box, cgrid_box, stencil_shape, rfactors,
ndim);
if ( hypre_BoxVolume(cfine_box) )
{
hypre_AppendBox(cfine_box, union_boxes);
hypre_CopyBox(cfine_box, hypre_BoxArrayBox(stencil_box_extents, i));
for (j= 0; j< ndim; j++)
{
hypre_BoxIMin(cfine_box)[j]-= cstart[j];
hypre_BoxIMax(cfine_box)[j]-= cstart[j];
}
hypre_CopyBox(cfine_box, hypre_BoxArrayBox(stencil_box_extents, i));
}
else
{
hypre_BoxSetExtents(hypre_BoxArrayBox(stencil_box_extents, i),
zero_index, neg_index);
}
hypre_BoxDestroy(cfine_box);
}
else /* centre */
{
hypre_BoxSetExtents(hypre_BoxArrayBox(stencil_box_extents, i),
zero_index, neg_index);
}
}
/*--------------------------------------------------------------------------
* Union the stencil_box_extents to get the full CF extents and append to
* the end of the stencil_box_extents BoxArray. Then shift the unioned boxes
* by cstart.
*--------------------------------------------------------------------------*/
if (hypre_BoxArraySize(union_boxes) > 1)
{
hypre_UnionBoxes(union_boxes);
}
hypre_ForBoxI(i, union_boxes)
{
hypre_AppendBox(hypre_BoxArrayBox(union_boxes, i), stencil_box_extents);
}
/*--------------------------------------------------------------------------
* hypre_Maxwell_Grad.c
* Forms a node-to-edge gradient operator. Looping over the
* edge grid so that each processor fills up only its own rows. Each
* processor will have its processor interface nodal ranks.
* Loops over two types of boxes, interior of grid boxes and boundary
* of boxes. Algo:
* find all nodal and edge physical boundary points and set
* the appropriate flag to be 0 at a boundary dof.
* set -1's in value array
* for each edge box,
* for interior
* {
* connect edge ijk (row) to nodes (col) connected to this edge
* and change -1 to 1 if needed;
* }
* for boundary layers
* {
* if edge not on the physical boundary connect only the nodes
* that are not on the physical boundary
* }
* set parcsr matrix with values;
*
* Note that the nodes that are on the processor interface can be
* on the physical boundary. But the off-proc edges connected to this
* type of node will be a physical boundary edge.
*
*--------------------------------------------------------------------------*/
hypre_ParCSRMatrix *
hypre_Maxwell_Grad(hypre_SStructGrid *grid)
{
MPI_Comm comm = (grid -> comm);
HYPRE_IJMatrix T_grad;
hypre_ParCSRMatrix *parcsr_grad;
HYPRE_Int matrix_type= HYPRE_PARCSR;
hypre_SStructGrid *node_grid, *edge_grid;
hypre_SStructPGrid *pgrid;
hypre_StructGrid *var_grid;
hypre_BoxArray *boxes, *tmp_box_array1, *tmp_box_array2;
hypre_BoxArray *node_boxes, *edge_boxes, *cell_boxes;
hypre_Box *box, *cell_box;
hypre_Box layer, interior_box;
hypre_Box *box_piece;
hypre_BoxManager *boxman;
hypre_BoxManEntry *entry;
HYPRE_Int *inode, *jedge;
HYPRE_Int nrows, nnodes, *nflag, *eflag, *ncols;
HYPRE_Real *vals;
hypre_Index index;
hypre_Index loop_size, start, lindex;
hypre_Index shift, shift2;
hypre_Index *offsets, *varoffsets;
HYPRE_Int nparts= hypre_SStructGridNParts(grid);
HYPRE_Int ndim = hypre_SStructGridNDim(grid);
HYPRE_SStructVariable vartype_node, *vartype_edges;
HYPRE_SStructVariable *vartypes;
HYPRE_Int nvars, part;
HYPRE_Int i, j, k, m, n, d;
HYPRE_Int *direction, ndirection;
HYPRE_Int ilower, iupper;
HYPRE_Int jlower, jupper;
HYPRE_Int start_rank1, start_rank2, rank;
HYPRE_Int myproc;
HYPRE_Int ierr=0;
hypre_BoxInit(&layer, ndim);
hypre_BoxInit(&interior_box, ndim);
hypre_MPI_Comm_rank(comm, &myproc);
hypre_ClearIndex(shift);
for (i= 0; i< ndim; i++)
{
hypre_IndexD(shift, i)= -1;
}
/* To get the correct ranks, separate node & edge grids must be formed.
Note that the edge vars must be ordered the same way as is in grid.*/
HYPRE_SStructGridCreate(comm, ndim, nparts, &node_grid);
HYPRE_SStructGridCreate(comm, ndim, nparts, &edge_grid);
vartype_node = HYPRE_SSTRUCT_VARIABLE_NODE;
vartype_edges= hypre_TAlloc(HYPRE_SStructVariable, ndim);
/* Assuming the same edge variable types on all parts */
pgrid = hypre_SStructGridPGrid(grid, 0);
vartypes= hypre_SStructPGridVarTypes(pgrid);
nvars = hypre_SStructPGridNVars(pgrid);
k= 0;
for (i= 0; i< nvars; i++)
{
j= vartypes[i];
switch(j)
{
case 2:
{
vartype_edges[k]= HYPRE_SSTRUCT_VARIABLE_XFACE;
k++;
break;
}
case 3:
{
vartype_edges[k]= HYPRE_SSTRUCT_VARIABLE_YFACE;
k++;
break;
}
case 5:
{
vartype_edges[k]= HYPRE_SSTRUCT_VARIABLE_XEDGE;
k++;
break;
}
case 6:
{
vartype_edges[k]= HYPRE_SSTRUCT_VARIABLE_YEDGE;
k++;
break;
}
case 7:
{
vartype_edges[k]= HYPRE_SSTRUCT_VARIABLE_ZEDGE;
k++;
break;
}
} /* switch(j) */
} /* for (i= 0; i< nvars; i++) */
for (part= 0; part< nparts; part++)
{
pgrid= hypre_SStructGridPGrid(grid, part);
var_grid= hypre_SStructPGridCellSGrid(pgrid) ;
boxes= hypre_StructGridBoxes(var_grid);
hypre_ForBoxI(j, boxes)
{
box= hypre_BoxArrayBox(boxes, j);
HYPRE_SStructGridSetExtents(node_grid, part,
hypre_BoxIMin(box), hypre_BoxIMax(box));
HYPRE_SStructGridSetExtents(edge_grid, part,
hypre_BoxIMin(box), hypre_BoxIMax(box));
}
HYPRE_SStructGridSetVariables(node_grid, part, 1, &vartype_node);
HYPRE_SStructGridSetVariables(edge_grid, part, ndim, vartype_edges);
}
/*--------------------------------------------------------------------------
* hypre_CF_StenBox: Given a cgrid_box, a fgrid_box, and a stencil_shape,
* the stencil_shape direction. Returns an empty box if these two boxes
* are not connected in the stencil_shape direction.
*--------------------------------------------------------------------------*/
hypre_Box *
hypre_CF_StenBox( hypre_Box *fgrid_box,
hypre_Box *cgrid_box,
hypre_Index stencil_shape,
hypre_Index rfactors,
HYPRE_Int ndim )
{
hypre_Box coarsen_box;
hypre_Box contracted_box;
hypre_Box extended_box;
hypre_Box intersect_box;
hypre_Box *stenbox;
hypre_Box shift_cbox, shift_ibox;
hypre_Index size_cbox, size_ibox;
hypre_Index temp_index;
hypre_Index shift_index;
HYPRE_Int i, remainder, intersect_size;
hypre_ClearIndex(temp_index);
stenbox = hypre_BoxCreate();
/*--------------------------------------------------------------------------
* Coarsen the fine box, extend it, and shift it to determine if there
* is a reach between fgrid_box and cgrid_box in the stencil_shape direction.
* Note: the fine_box may not align as the index rule assumes:
* [a_0,a_1,a_2]x[b_0,b_1,b_2], a_i= c_i*rfactors[i]
* b_i= f_i*rfactors[i]+g_i, g_i= rfactors[i]-1.
* When fine_box does not, then there must be a sibling box. fine_box
* should be adjusted so that the flooring of the MapFineToCoarse does not
* introduce extra coarse nodes in the coarsened box. Only the lower bound
* needs to be adjusted.
*--------------------------------------------------------------------------*/
hypre_CopyBox(fgrid_box, &contracted_box);
for (i= 0; i< ndim; i++)
{
remainder= hypre_BoxIMin(&contracted_box)[i] % rfactors[i];
if (remainder)
{
hypre_BoxIMin(&contracted_box)[i]+= rfactors[i] - remainder;
}
}
hypre_StructMapFineToCoarse(hypre_BoxIMin(&contracted_box), temp_index,
rfactors, hypre_BoxIMin(&coarsen_box));
hypre_StructMapFineToCoarse(hypre_BoxIMax(&contracted_box), temp_index,
rfactors, hypre_BoxIMax(&coarsen_box));
hypre_ClearIndex(size_cbox);
for (i= 0; i< ndim; i++)
{
size_cbox[i] = hypre_BoxSizeD(&coarsen_box, i) - 1;
}
/*---------------------------------------------------------------------
* Extend the coarsened fgrid_box by one layer in each direction so
* that actual cf interface is reached. If only coarsen_box were
* extended, the actual cf interface may not be reached.
*---------------------------------------------------------------------*/
hypre_CopyBox(&coarsen_box, &extended_box);
/*hypre_StructMapFineToCoarse(hypre_BoxIMin(fgrid_box), temp_index,
rfactors, hypre_BoxIMin(&extended_box));
hypre_StructMapFineToCoarse(hypre_BoxIMax(fgrid_box), temp_index,
rfactors, hypre_BoxIMax(&extended_box));*/
for (i= 0; i< ndim; i++)
{
hypre_BoxIMin(&extended_box)[i]-=1;
hypre_BoxIMax(&extended_box)[i]+=1;
}
hypre_IntersectBoxes(&extended_box, cgrid_box, &intersect_box);
intersect_size= hypre_BoxVolume(&intersect_box);
if (intersect_size == 0)
{
hypre_CopyBox(&intersect_box, stenbox);
return stenbox;
}
hypre_ClearIndex(size_ibox);
for (i= 0; i< ndim; i++)
{
size_ibox[i] = hypre_BoxSizeD(&intersect_box, i) - 1;
}
/*---------------------------------------------------------------------
* To find the box extents that must be loop over, we need to take the
* "opposite" stencil_shape and shift the coarsen and extended boxes.
*---------------------------------------------------------------------*/
hypre_SetIndex(shift_index,
-size_ibox[0]*stencil_shape[0],
-size_ibox[1]*stencil_shape[1],
-size_ibox[2]*stencil_shape[2]);
hypre_AddIndex(shift_index, hypre_BoxIMin(&intersect_box), hypre_BoxIMin(&shift_ibox));
hypre_AddIndex(shift_index, hypre_BoxIMax(&intersect_box), hypre_BoxIMax(&shift_ibox));
hypre_IntersectBoxes(&shift_ibox, &intersect_box, &shift_ibox);
hypre_SetIndex(shift_index,
-size_cbox[0]*stencil_shape[0],
-size_cbox[1]*stencil_shape[1],
-size_cbox[2]*stencil_shape[2]);
hypre_AddIndex(shift_index, hypre_BoxIMin(&coarsen_box), hypre_BoxIMin(&shift_cbox));
hypre_AddIndex(shift_index, hypre_BoxIMax(&coarsen_box), hypre_BoxIMax(&shift_cbox));
hypre_IntersectBoxes(&shift_cbox, &coarsen_box, &shift_cbox);
/*---------------------------------------------------------------------
* shift_ibox & shift_cbox will contain the loop extents. Shifting
* shift_cbox by -stencil_shape and then intersecting with shift_ibox
* gives the exact extents.
*---------------------------------------------------------------------*/
hypre_SetIndex(shift_index, -stencil_shape[0], -stencil_shape[1], -stencil_shape[2]);
hypre_AddIndex(shift_index, hypre_BoxIMin(&shift_cbox), hypre_BoxIMin(&shift_cbox));
hypre_AddIndex(shift_index, hypre_BoxIMax(&shift_cbox), hypre_BoxIMax(&shift_cbox));
hypre_IntersectBoxes(&shift_cbox, &shift_ibox, stenbox);
return stenbox;
}
