/*
----------------------------------------------------
set the component weights from the compids[] vector
created -- 95oct05, cca
modified -- 95nov29, cca
----------------------------------------------------
*/
void
GPart_setCweights (
GPart *gpart
) {
Graph *g ;
int ierr, ii, last, ncomp, now, nvtx, u, usize, v, w ;
int *compids, *cweights, *list, *uadj, *vwghts ;
/*
--------------
check the data
--------------
*/
if ( gpart == NULL ) {
fprintf(stderr, "\n fatal error in GPart_setCweights(%p)"
"\n bad input\n", gpart) ;
exit(-1) ;
}
if ( (nvtx = gpart->nvtx) <= 0 || (g = gpart->g) == NULL ) {
fprintf(stderr, "\n fatal error in GPart_setCweights(%p)"
"\n bad Gpart object\n", gpart) ;
exit(-1) ;
}
/*
----------------------------------------------------------
set the component id of all non-multisector vertices to -1
----------------------------------------------------------
*/
compids = IV_entries(&gpart->compidsIV) ;
for ( v = 0 ; v < nvtx ; v++ ) {
if ( compids[v] != 0 ) {
compids[v] = -1 ;
}
}
/*
----------------------------------------------------------
compute the number of components and set the component ids
----------------------------------------------------------
*/
list = IVinit(nvtx, -1) ;
ncomp = 0 ;
for ( v = 0 ; v < nvtx ; v++ ) {
if ( compids[v] == -1 ) {
compids[v] = ++ncomp ;
now = last = 0 ;
list[now] = v ;
while ( now <= last ) {
u = list[now++] ;
Graph_adjAndSize(g, u, &usize, &uadj) ;
for ( ii = 0 ; ii < usize ; ii++ ) {
if ( (w = uadj[ii]) < nvtx && compids[w] == -1 ) {
compids[w] = ncomp ;
list[++last] = w ;
}
}
}
}
}
/*
----------------------------
set the number of components
----------------------------
*/
gpart->ncomp = ncomp ;
/*
-------------------------
set the component weights
-------------------------
*/
IV_setSize(&gpart->cweightsIV, 1 + ncomp) ;
cweights = IV_entries(&gpart->cweightsIV) ;
IVzero(1 + ncomp, cweights) ;
if ( (vwghts = gpart->g->vwghts) != NULL ) {
for ( v = 0 ; v < nvtx ; v++ ) {
cweights[compids[v]] += vwghts[v] ;
}
} else {
for ( v = 0 ; v < nvtx ; v++ ) {
cweights[compids[v]]++ ;
}
}
/*
------------------------
free the working storage
------------------------
*/
IVfree(list) ;
return ; }
/*
--------------------------------------------------
purpose -- to solve a linear system
(A - sigma*B) sol[] = rhs[]
data -- pointer to bridge data object
*pnrows -- # of rows in x[] and y[]
*pncols -- # of columns in x[] and y[]
rhs[] -- vector that holds right hand sides
NOTE: the rhs[] vector is global, not a portion
sol[] -- vector to hold solutions
NOTE: the sol[] vector is global, not a portion
note: rhs[] and sol[] can be the same array.
on return, *perror holds an error code.
created -- 98aug28, cca & jcp
--------------------------------------------------
*/
void
JimSolveMPI (
int *pnrows,
int *pncols,
double rhs[],
double sol[],
void *data,
int *perror
) {
BridgeMPI *bridge = (BridgeMPI *) data ;
DenseMtx *mtx, *newmtx ;
int irow, jj, jcol, kk, myid, ncols = *pncols,
neqns, nowned, tag = 0 ;
int *vtxmap ;
int stats[4] ;
IV *mapIV ;
#if MYDEBUG > 0
double t1, t2 ;
count_JimSolve++ ;
MARKTIME(t1) ;
if ( bridge->myid == 0 ) {
fprintf(stdout, "\n (%d) JimSolve() start", count_JimSolve) ;
fflush(stdout) ;
}
#endif
#if MYDEBUG > 1
fprintf(bridge->msgFile, "\n (%d) JimSolve() start", count_JimSolve) ;
fflush(bridge->msgFile) ;
#endif
MPI_Barrier(bridge->comm) ;
/*
---------------------------------------------
slide the owned rows of rhs down in the array
---------------------------------------------
*/
vtxmap = IV_entries(bridge->vtxmapIV) ;
neqns = bridge->neqns ;
myid = bridge->myid ;
nowned = IV_size(bridge->myownedIV) ;
for ( jcol = jj = kk = 0 ; jcol < ncols ; jcol++ ) {
for ( irow = 0 ; irow < neqns ; irow++, jj++ ) {
if ( vtxmap[irow] == myid ) {
sol[kk++] = rhs[jj] ;
}
}
}
if ( kk != nowned * ncols ) {
fprintf(stderr, "\n proc %d : kk %d, nowned %d, ncols %d",
myid, kk, nowned, ncols) ;
exit(-1) ;
}
/*
----------------------------------------
call the method that assumes local input
----------------------------------------
*/
if ( bridge->msglvl > 1 ) {
fprintf(bridge->msgFile, "\n calling SolveMPI()") ;
fflush(bridge->msgFile) ;
}
SolveMPI(&nowned, pncols, sol, sol, data, perror) ;
if ( bridge->msglvl > 1 ) {
fprintf(bridge->msgFile, "\n return from SolveMPI()") ;
fflush(bridge->msgFile) ;
}
/*
------------------------------------------
gather all the entries onto processor zero
------------------------------------------
*/
mtx = DenseMtx_new() ;
DenseMtx_init(mtx, SPOOLES_REAL, 0, 0, nowned, ncols, 1, nowned) ;
DVcopy (nowned*ncols, DenseMtx_entries(mtx), sol) ;
IVcopy(nowned, mtx->rowind, IV_entries(bridge->myownedIV)) ;
mapIV = IV_new() ;
IV_init(mapIV, neqns, NULL) ;
IV_fill(mapIV, 0) ;
IVfill(4, stats, 0) ;
if ( bridge->msglvl > 1 ) {
fprintf(bridge->msgFile, "\n calling DenseMtx_split()()") ;
fflush(bridge->msgFile) ;
}
newmtx = DenseMtx_MPI_splitByRows(mtx, mapIV, stats, bridge->msglvl,
bridge->msgFile, tag, bridge->comm) ;
if ( bridge->msglvl > 1 ) {
fprintf(bridge->msgFile, "\n return from DenseMtx_split()()") ;
fflush(bridge->msgFile) ;
}
DenseMtx_free(mtx) ;
mtx = newmtx ;
IV_free(mapIV) ;
if ( myid == 0 ) {
DVcopy(neqns*ncols, sol, DenseMtx_entries(mtx)) ;
}
DenseMtx_free(mtx) ;
/*
---------------------------------------------
broadcast the entries to the other processors
---------------------------------------------
*/
if ( bridge->msglvl > 1 ) {
fprintf(bridge->msgFile, "\n calling MPI_Bcast()()") ;
fflush(bridge->msgFile) ;
}
MPI_Bcast((void *) sol, neqns*ncols, MPI_DOUBLE, 0, bridge->comm) ;
if ( bridge->msglvl > 1 ) {
fprintf(bridge->msgFile, "\n return from MPI_Bcast()()") ;
fflush(bridge->msgFile) ;
}
MPI_Barrier(bridge->comm) ;
/*
------------------------------------------------------------------
set the error. (this is simple since when the spooles codes detect
a fatal error, they print out a message to stderr and exit.)
------------------------------------------------------------------
*/
*perror = 0 ;
#if MYDEBUG > 0
MARKTIME(t2) ;
time_JimSolve += t2 - t1 ;
if ( bridge->myid == 0 ) {
fprintf(stdout, "\n (%d) JimSolve() end", count_JimSolve) ;
fprintf(stdout, ", %8.3f seconds, %8.3f total time",
t2 - t1, time_JimSolve) ;
fflush(stdout) ;
}
#endif
#if MYDEBUG > 1
fprintf(bridge->msgFile, "\n (%d) JimSolve() end", count_JimSolve) ;
fprintf(bridge->msgFile, ", %8.3f seconds, %8.3f total time",
t2 - t1, time_JimSolve) ;
fflush(bridge->msgFile) ;
#endif
return ; }
/*--------------------------------------------------------------------*/
int
main ( int argc, char *argv[] ) {
/*
--------------------------------------------------
all-in-one program to solve A X = B
using a multithreaded factorization and solve
We use a patch-and-go strategy
for the factorization without pivoting
(1) read in matrix entries and form DInpMtx object
(2) form Graph object
(3) order matrix and form front tree
(4) get the permutation, permute the matrix and
front tree and get the symbolic factorization
(5) compute the numeric factorization
(6) read in right hand side entries
(7) compute the solution
created -- 98jun04, cca
--------------------------------------------------
*/
/*--------------------------------------------------------------------*/
char *matrixFileName, *rhsFileName ;
DenseMtx *mtxB, *mtxX ;
Chv *rootchv ;
ChvManager *chvmanager ;
double fudge, imag, real, tau = 100., toosmall, value ;
double cpus[10] ;
DV *cumopsDV ;
ETree *frontETree ;
FrontMtx *frontmtx ;
FILE *inputFile, *msgFile ;
Graph *graph ;
InpMtx *mtxA ;
int error, ient, irow, jcol, jrhs, jrow, lookahead, msglvl,
ncol, nedges, nent, neqns, nfront, nrhs, nrow, nthread,
patchAndGoFlag, seed,
storeids, storevalues, symmetryflag, type ;
int *newToOld, *oldToNew ;
int stats[20] ;
IV *newToOldIV, *oldToNewIV, *ownersIV ;
IVL *adjIVL, *symbfacIVL ;
SolveMap *solvemap ;
SubMtxManager *mtxmanager ;
/*--------------------------------------------------------------------*/
/*
--------------------
get input parameters
--------------------
*/
if ( argc != 14 ) {
fprintf(stdout, "\n"
"\n usage: %s msglvl msgFile type symmetryflag patchAndGoFlag"
"\n fudge toosmall storeids storevalues"
"\n matrixFileName rhsFileName seed"
"\n msglvl -- message level"
"\n msgFile -- message file"
"\n type -- type of entries"
"\n 1 (SPOOLES_REAL) -- real entries"
"\n 2 (SPOOLES_COMPLEX) -- complex entries"
"\n symmetryflag -- type of matrix"
"\n 0 (SPOOLES_SYMMETRIC) -- symmetric entries"
"\n 1 (SPOOLES_HERMITIAN) -- Hermitian entries"
"\n 2 (SPOOLES_NONSYMMETRIC) -- nonsymmetric entries"
"\n patchAndGoFlag -- flag for the patch-and-go strategy"
"\n 0 -- none, stop factorization"
"\n 1 -- optimization strategy"
"\n 2 -- structural analysis strategy"
"\n fudge -- perturbation parameter"
"\n toosmall -- upper bound on a small pivot"
"\n storeids -- flag to store ids of small pivots"
"\n storevalues -- flag to store perturbations"
"\n matrixFileName -- matrix file name, format"
"\n nrow ncol nent"
"\n irow jcol entry"
"\n ..."
"\n note: indices are zero based"
"\n rhsFileName -- right hand side file name, format"
"\n nrow nrhs "
"\n ..."
"\n jrow entry(jrow,0) ... entry(jrow,nrhs-1)"
"\n ..."
"\n seed -- random number seed, used for ordering"
"\n nthread -- number of threads"
"\n", argv[0]) ;
return(0) ;
}
msglvl = atoi(argv[1]) ;
if ( strcmp(argv[2], "stdout") == 0 ) {
msgFile = stdout ;
} else if ( (msgFile = fopen(argv[2], "a")) == NULL ) {
fprintf(stderr, "\n fatal error in %s"
"\n unable to open file %s\n",
argv[0], argv[2]) ;
return(-1) ;
}
type = atoi(argv[3]) ;
symmetryflag = atoi(argv[4]) ;
patchAndGoFlag = atoi(argv[5]) ;
fudge = atof(argv[6]) ;
toosmall = atof(argv[7]) ;
storeids = atoi(argv[8]) ;
storevalues = atoi(argv[9]) ;
matrixFileName = argv[10] ;
rhsFileName = argv[11] ;
seed = atoi(argv[12]) ;
nthread = atoi(argv[13]) ;
/*--------------------------------------------------------------------*/
/*
--------------------------------------------
STEP 1: read the entries from the input file
and create the InpMtx object
--------------------------------------------
*/
if ( (inputFile = fopen(matrixFileName, "r")) == NULL ) {
fprintf(stderr, "\n unable to open file %s", matrixFileName) ;
spoolesFatal();
}
fscanf(inputFile, "%d %d %d", &nrow, &ncol, &nent) ;
neqns = nrow ;
mtxA = InpMtx_new() ;
InpMtx_init(mtxA, INPMTX_BY_ROWS, type, nent, 0) ;
if ( type == SPOOLES_REAL ) {
for ( ient = 0 ; ient < nent ; ient++ ) {
fscanf(inputFile, "%d %d %le", &irow, &jcol, &value) ;
InpMtx_inputRealEntry(mtxA, irow, jcol, value) ;
}
} else {
for ( ient = 0 ; ient < nent ; ient++ ) {
fscanf(inputFile, "%d %d %le %le", &irow, &jcol, &real, &imag) ;
InpMtx_inputComplexEntry(mtxA, irow, jcol, real, imag) ;
}
}
fclose(inputFile) ;
InpMtx_changeStorageMode(mtxA, INPMTX_BY_VECTORS) ;
if ( msglvl > 1 ) {
fprintf(msgFile, "\n\n input matrix") ;
InpMtx_writeForHumanEye(mtxA, msgFile) ;
fflush(msgFile) ;
}
/*--------------------------------------------------------------------*/
/*
-------------------------------------------------
STEP 2 : find a low-fill ordering
(1) create the Graph object
(2) order the graph using multiple minimum degree
-------------------------------------------------
*/
graph = Graph_new() ;
adjIVL = InpMtx_fullAdjacency(mtxA) ;
nedges = IVL_tsize(adjIVL) ;
Graph_init2(graph, 0, neqns, 0, nedges, neqns, nedges, adjIVL,
NULL, NULL) ;
if ( msglvl > 1 ) {
fprintf(msgFile, "\n\n graph of the input matrix") ;
Graph_writeForHumanEye(graph, msgFile) ;
fflush(msgFile) ;
}
frontETree = orderViaMMD(graph, seed, msglvl, msgFile) ;
if ( msglvl > 1 ) {
fprintf(msgFile, "\n\n front tree from ordering") ;
ETree_writeForHumanEye(frontETree, msgFile) ;
fflush(msgFile) ;
}
/*--------------------------------------------------------------------*/
/*
-----------------------------------------------------
STEP 3: get the permutation, permute the matrix and
front tree and get the symbolic factorization
-----------------------------------------------------
*/
oldToNewIV = ETree_oldToNewVtxPerm(frontETree) ;
oldToNew = IV_entries(oldToNewIV) ;
newToOldIV = ETree_newToOldVtxPerm(frontETree) ;
newToOld = IV_entries(newToOldIV) ;
ETree_permuteVertices(frontETree, oldToNewIV) ;
InpMtx_permute(mtxA, oldToNew, oldToNew) ;
InpMtx_mapToUpperTriangle(mtxA) ;
InpMtx_changeCoordType(mtxA, INPMTX_BY_CHEVRONS) ;
InpMtx_changeStorageMode(mtxA, INPMTX_BY_VECTORS) ;
symbfacIVL = SymbFac_initFromInpMtx(frontETree, mtxA) ;
if ( msglvl > 1 ) {
fprintf(msgFile, "\n\n old-to-new permutation vector") ;
IV_writeForHumanEye(oldToNewIV, msgFile) ;
fprintf(msgFile, "\n\n new-to-old permutation vector") ;
IV_writeForHumanEye(newToOldIV, msgFile) ;
fprintf(msgFile, "\n\n front tree after permutation") ;
ETree_writeForHumanEye(frontETree, msgFile) ;
fprintf(msgFile, "\n\n input matrix after permutation") ;
InpMtx_writeForHumanEye(mtxA, msgFile) ;
fprintf(msgFile, "\n\n symbolic factorization") ;
IVL_writeForHumanEye(symbfacIVL, msgFile) ;
fflush(msgFile) ;
}
/*--------------------------------------------------------------------*/
/*
------------------------------------------
STEP 4: initialize the front matrix object
and the PatchAndGoInfo object to handle
small pivots
------------------------------------------
*/
frontmtx = FrontMtx_new() ;
mtxmanager = SubMtxManager_new() ;
SubMtxManager_init(mtxmanager, LOCK_IN_PROCESS, 0) ;
FrontMtx_init(frontmtx, frontETree, symbfacIVL, type, symmetryflag,
FRONTMTX_DENSE_FRONTS, SPOOLES_NO_PIVOTING, LOCK_IN_PROCESS,
0, NULL, mtxmanager, msglvl, msgFile) ;
if ( patchAndGoFlag == 1 ) {
frontmtx->patchinfo = PatchAndGoInfo_new() ;
PatchAndGoInfo_init(frontmtx->patchinfo, 1, toosmall, fudge,
storeids, storevalues) ;
} else if ( patchAndGoFlag == 2 ) {
frontmtx->patchinfo = PatchAndGoInfo_new() ;
PatchAndGoInfo_init(frontmtx->patchinfo, 2, toosmall, fudge,
storeids, storevalues) ;
}
/*--------------------------------------------------------------------*/
/*
------------------------------------------
STEP 5: setup the domain decomposition map
------------------------------------------
*/
if ( nthread > (nfront = FrontMtx_nfront(frontmtx)) ) {
nthread = nfront ;
}
cumopsDV = DV_new() ;
DV_init(cumopsDV, nthread, NULL) ;
ownersIV = ETree_ddMap(frontETree, type, symmetryflag,
cumopsDV, 1./(2.*nthread)) ;
DV_free(cumopsDV) ;
/*--------------------------------------------------------------------*/
/*
-----------------------------------------------------
STEP 6: compute the numeric factorization in parallel
-----------------------------------------------------
*/
chvmanager = ChvManager_new() ;
ChvManager_init(chvmanager, LOCK_IN_PROCESS, 1) ;
DVfill(10, cpus, 0.0) ;
IVfill(20, stats, 0) ;
lookahead = 0 ;
rootchv = FrontMtx_MT_factorInpMtx(frontmtx, mtxA, tau, 0.0,
chvmanager, ownersIV, lookahead,
&error, cpus, stats, msglvl, msgFile) ;
if ( patchAndGoFlag == 1 ) {
if ( frontmtx->patchinfo->fudgeIV != NULL ) {
fprintf(msgFile, "\n small pivots found at these locations") ;
IV_writeForHumanEye(frontmtx->patchinfo->fudgeIV, msgFile) ;
}
PatchAndGoInfo_free(frontmtx->patchinfo) ;
} else if ( patchAndGoFlag == 2 ) {
if ( frontmtx->patchinfo->fudgeIV != NULL ) {
fprintf(msgFile, "\n small pivots found at these locations") ;
IV_writeForHumanEye(frontmtx->patchinfo->fudgeIV, msgFile) ;
}
if ( frontmtx->patchinfo->fudgeDV != NULL ) {
fprintf(msgFile, "\n perturbations") ;
DV_writeForHumanEye(frontmtx->patchinfo->fudgeDV, msgFile) ;
}
PatchAndGoInfo_free(frontmtx->patchinfo) ;
}
ChvManager_free(chvmanager) ;
if ( msglvl > 1 ) {
fprintf(msgFile, "\n\n factor matrix") ;
FrontMtx_writeForHumanEye(frontmtx, msgFile) ;
fflush(msgFile) ;
}
if ( rootchv != NULL ) {
fprintf(msgFile, "\n\n matrix found to be singular\n") ;
spoolesFatal();
}
if ( error >= 0 ) {
fprintf(msgFile, "\n\n fatal error at front %d\n", error) ;
spoolesFatal();
}
/*
--------------------------------------
STEP 7: post-process the factorization
--------------------------------------
*/
FrontMtx_postProcess(frontmtx, msglvl, msgFile) ;
if ( msglvl > 1 ) {
fprintf(msgFile, "\n\n factor matrix after post-processing") ;
FrontMtx_writeForHumanEye(frontmtx, msgFile) ;
fflush(msgFile) ;
}
/*--------------------------------------------------------------------*/
/*
-----------------------------------------
STEP 8: read the right hand side matrix B
-----------------------------------------
*/
if ( (inputFile = fopen(rhsFileName, "r")) == NULL ) {
fprintf(stderr, "\n unable to open file %s", rhsFileName) ;
spoolesFatal();
}
fscanf(inputFile, "%d %d", &nrow, &nrhs) ;
mtxB = DenseMtx_new() ;
DenseMtx_init(mtxB, type, 0, 0, neqns, nrhs, 1, neqns) ;
DenseMtx_zero(mtxB) ;
if ( type == SPOOLES_REAL ) {
for ( irow = 0 ; irow < nrow ; irow++ ) {
fscanf(inputFile, "%d", &jrow) ;
for ( jrhs = 0 ; jrhs < nrhs ; jrhs++ ) {
fscanf(inputFile, "%le", &value) ;
DenseMtx_setRealEntry(mtxB, jrow, jrhs, value) ;
}
}
} else {
for ( irow = 0 ; irow < nrow ; irow++ ) {
fscanf(inputFile, "%d", &jrow) ;
for ( jrhs = 0 ; jrhs < nrhs ; jrhs++ ) {
fscanf(inputFile, "%le %le", &real, &imag) ;
DenseMtx_setComplexEntry(mtxB, jrow, jrhs, real, imag) ;
}
}
}
fclose(inputFile) ;
if ( msglvl > 1 ) {
fprintf(msgFile, "\n\n rhs matrix in original ordering") ;
DenseMtx_writeForHumanEye(mtxB, msgFile) ;
fflush(msgFile) ;
}
/*--------------------------------------------------------------------*/
/*
--------------------------------------------------------------
STEP 9: permute the right hand side into the original ordering
--------------------------------------------------------------
*/
DenseMtx_permuteRows(mtxB, oldToNewIV) ;
if ( msglvl > 1 ) {
fprintf(msgFile, "\n\n right hand side matrix in new ordering") ;
DenseMtx_writeForHumanEye(mtxB, msgFile) ;
fflush(msgFile) ;
}
/*--------------------------------------------------------------------*/
/*
--------------------------------------------------------
STEP 10: get the solve map object for the parallel solve
--------------------------------------------------------
*/
solvemap = SolveMap_new() ;
SolveMap_ddMap(solvemap, type, FrontMtx_upperBlockIVL(frontmtx),
FrontMtx_lowerBlockIVL(frontmtx), nthread, ownersIV,
FrontMtx_frontTree(frontmtx), seed, msglvl, msgFile) ;
/*--------------------------------------------------------------------*/
/*
--------------------------------------------
STEP 11: solve the linear system in parallel
--------------------------------------------
*/
mtxX = DenseMtx_new() ;
DenseMtx_init(mtxX, type, 0, 0, neqns, nrhs, 1, neqns) ;
DenseMtx_zero(mtxX) ;
FrontMtx_MT_solve(frontmtx, mtxX, mtxB, mtxmanager, solvemap,
cpus, msglvl, msgFile) ;
if ( msglvl > 1 ) {
fprintf(msgFile, "\n\n solution matrix in new ordering") ;
DenseMtx_writeForHumanEye(mtxX, msgFile) ;
fflush(msgFile) ;
}
/*--------------------------------------------------------------------*/
/*
--------------------------------------------------------
STEP 12: permute the solution into the original ordering
--------------------------------------------------------
*/
DenseMtx_permuteRows(mtxX, newToOldIV) ;
if ( msglvl > 0 ) {
fprintf(msgFile, "\n\n solution matrix in original ordering") ;
DenseMtx_writeForHumanEye(mtxX, msgFile) ;
fflush(msgFile) ;
}
/*--------------------------------------------------------------------*/
/*
-----------
free memory
-----------
*/
FrontMtx_free(frontmtx) ;
DenseMtx_free(mtxX) ;
DenseMtx_free(mtxB) ;
IV_free(newToOldIV) ;
IV_free(oldToNewIV) ;
InpMtx_free(mtxA) ;
ETree_free(frontETree) ;
IVL_free(symbfacIVL) ;
SubMtxManager_free(mtxmanager) ;
Graph_free(graph) ;
SolveMap_free(solvemap) ;
IV_free(ownersIV) ;
/*--------------------------------------------------------------------*/
return(1) ; }
/*
-------------------------------------------------------
make the map from wide separator vertices Y
to components {0, 1, 2, 3}.
YCmap[y] == 0 --> y is not adjacent to either component
YCmap[y] == 1 --> y is adjacent to only component 1
YCmap[y] == 2 --> y is adjacent to only component 2
YCmap[y] == 3 --> y is adjacent to components 1 and 2
created -- 96jun09, cca
-------------------------------------------------------
*/
IV *
GPart_makeYCmap (
GPart *gpart,
IV *YVmapIV
) {
Graph *g ;
int ii, nvtx, nY, v, vsize, w, y ;
int *compids, *vadj, *VYmap, *YCmap, *YVmap ;
IV *YCmapIV ;
/*
---------------
check the input
---------------
*/
if ( gpart == NULL || (g = gpart->g) == NULL
|| (nvtx = gpart->nvtx) <= 0
|| YVmapIV == NULL || (nY = IV_size(YVmapIV)) <= 0
|| (YVmap = IV_entries(YVmapIV)) == NULL ) {
fprintf(stderr, "\n fatal error in GPart_makeYCmap(%p,%p)"
"\n bad input\n", gpart, YVmapIV) ;
if ( YVmapIV != NULL ) {
fprintf(stderr, "\n YVmapIV") ;
IV_writeForHumanEye(YVmapIV, stderr) ;
}
exit(-1) ;
}
compids = IV_entries(&gpart->compidsIV) ;
/*
--------------------------------
generate the inverse V --> Y map
--------------------------------
*/
VYmap = IVinit(nvtx, -1) ;
for ( y = 0 ; y < nY ; y++ ) {
v = YVmap[y] ;
VYmap[v] = y ;
}
/*
------------------------------------
initialize the Y --> C map IV object
------------------------------------
*/
YCmapIV = IV_new();
IV_init(YCmapIV, nY, NULL) ;
YCmap = IV_entries(YCmapIV) ;
/*
---------------
fill the fields
---------------
*/
for ( y = 0 ; y < nY ; y++ ) {
YCmap[y] = 0 ;
v = YVmap[y] ;
Graph_adjAndSize(g, v, &vsize, &vadj) ;
for ( ii = 0 ; ii < vsize ; ii++ ) {
w = vadj[ii] ;
if ( w < nvtx && VYmap[w] == -1 ) {
/*
--------------------------------
w is not in the wide separator Y
--------------------------------
*/
if ( compids[w] == 1 ) {
/*
---------------------------------------
v is adjacent to component 1 setminus Y
---------------------------------------
*/
if ( YCmap[y] == 2 ) {
/*
------------------------------------
v is already adjacent to component 2
so it is adjacent to both components
------------------------------------
*/
YCmap[y] = 3 ;
break ;
} else {
/*
----------------------------------
set map value but keep on checking
----------------------------------
*/
YCmap[y] = 1 ;
}
} else if ( compids[w] == 2 ) {
/*
---------------------------------------
v is adjacent to component 2 setminus Y
---------------------------------------
*/
if ( YCmap[y] == 1 ) {
/*
------------------------------------
v is already adjacent to component 1
so it is adjacent to both components
------------------------------------
*/
YCmap[y] = 3 ;
break ;
} else {
/*
----------------------------------
set map value but keep on checking
----------------------------------
*/
YCmap[y] = 2 ;
}
}
}
}
}
/*
------------------------
free the working storage
------------------------
*/
IVfree(VYmap) ;
return(YCmapIV) ; }
/*
-----------------------------------------------------------------
compress a tree based on a map from old vertices to new vertices.
the restriction on the map is that the set {u | map[u] = U} must
be connected for all U.
created -- 95nov15, cca
modified -- 96jan04, cca
bug fixed, N computed incorrectly
modified -- 96jun23, cca
in calling sequence, int map[] converted to IV *mapIV
-----------------------------------------------------------------
*/
Tree *
Tree_compress (
Tree *tree,
IV *mapIV
) {
int n, N, u, U, v, V ;
int *head, *link, *map ;
Tree *tree2 ;
/*
---------------
check the input
---------------
*/
if ( tree == NULL
|| (n = tree->n) <= 0
|| mapIV == NULL
|| n != IV_size(mapIV)
|| (map = IV_entries(mapIV)) == NULL ) {
fprintf(stderr, "\n fatal error in Tree_compress(%p,%p)"
"\n bad input\n", tree, mapIV) ;
exit(-1) ;
}
/*
-----------------------
initialize the new tree
-----------------------
*/
N = 1 + IV_max(mapIV) ;
tree2 = Tree_new() ;
Tree_init1(tree2, N) ;
/*
-----------------------------------------------------------
get the head/link construct to map old nodes into new nodes
-----------------------------------------------------------
*/
head = IVinit(N, -1) ;
link = IVinit(n, -1) ;
for ( v = 0 ; v < n ; v++ ) {
if ( (V = map[v]) < 0 || V >= N ) {
fprintf(stderr, "\n fatal error in Tree_compress(%p,%p)"
"\n map[%d] = %d, N = %d\n", tree, map, v, V, N) ;
exit(-1) ;
}
link[v] = head[V] ;
head[V] = v ;
}
/*
---------------------
fill the tree vectors
---------------------
*/
for ( U = 0 ; U < N ; U++ ) {
for ( u = head[U] ; u != -1 ; u = link[u] ) {
if ( (v = tree->par[u]) == -1 ) {
tree2->par[U] = -1 ;
break ;
} else if ( (V = map[v]) != U ) {
tree2->par[U] = V ;
break ;
}
}
}
Tree_setFchSibRoot(tree2) ;
/*
------------------------
free the working storage
------------------------
*/
IVfree(head) ;
IVfree(link) ;
return(tree2) ; }
/*
-------------------------------------------------------
purpose -- merge the front tree allowing a parent
to absorb all children when that creates
at most maxzeros zero entries inside a front
return --
IV object that has the old front to new front map
created -- 98jan29, cca
-------------------------------------------------------
*/
ETree *
ETree_mergeFrontsAll (
ETree *etree,
int maxzeros,
IV *nzerosIV
) {
ETree *etree2 ;
int cost, J, Jall, K, KandBnd, nfront, nvtx, nnew ;
int *bndwghts, *fch, *map, *nodwghts, *nzeros, *rep, *sib, *temp ;
IV *mapIV ;
Tree *tree ;
/*
---------------
check the input
---------------
*/
if ( etree == NULL || nzerosIV == NULL
|| (nfront = etree->nfront) <= 0
|| (nvtx = etree->nvtx) <= 0 ) {
fprintf(stderr, "\n fatal error in ETree_mergeFrontsAll(%p,%d,%p)"
"\n bad input\n", etree, maxzeros, nzerosIV) ;
if ( etree != NULL ) {
fprintf(stderr, "\n nfront = %d, nvtx = %d",
etree->nfront, etree->nvtx) ;
}
spoolesFatal();
}
if ( IV_size(nzerosIV) != nfront ) {
fprintf(stderr, "\n fatal error in ETree_mergeFrontsAll(%p,%d,%p)"
"\n size(nzerosIV) = %d, nfront = %d\n",
etree, maxzeros, nzerosIV, IV_size(nzerosIV), nfront) ;
spoolesFatal();
}
nzeros = IV_entries(nzerosIV) ;
/*
----------------------
set up working storage
----------------------
*/
tree = etree->tree ;
fch = ETree_fch(etree) ;
sib = ETree_sib(etree) ;
nodwghts = IVinit(nfront, 0) ;
IVcopy(nfront, nodwghts, ETree_nodwghts(etree)) ;
bndwghts = ETree_bndwghts(etree) ;
rep = IVinit(nfront, -1) ;
IVramp(nfront, rep, 0, 1) ;
/*
------------------------------------------
perform a post-order traversal of the tree
------------------------------------------
*/
for ( K = Tree_postOTfirst(tree) ;
K != -1 ;
K = Tree_postOTnext(tree, K) ) {
#if MYDEBUG > 0
fprintf(stdout, "\n\n ##### visiting front %d", K) ;
fflush(stdout) ;
#endif
if ( (J = fch[K]) != -1 ) {
KandBnd = nodwghts[K] + bndwghts[K] ;
Jall = 0 ;
cost = 2*nzeros[K] ;
for ( J = fch[K] ; J != -1 ; J = sib[J] ) {
Jall += nodwghts[J] ;
cost -= nodwghts[J]*nodwghts[J] ;
cost += 2*nodwghts[J]*(KandBnd - bndwghts[J]) ;
cost += 2*nzeros[J] ;
}
cost += Jall*Jall ;
cost = cost/2 ;
#if MYDEBUG > 0
fprintf(stdout, "\n cost = %d", cost) ;
fflush(stdout) ;
#endif
if ( cost <= maxzeros ) {
for ( J = fch[K] ; J != -1 ; J = sib[J] ) {
#if MYDEBUG > 0
fprintf(stdout, "\n merging %d into %d", J, K) ;
fflush(stdout) ;
#endif
rep[J] = K ;
nodwghts[K] += nodwghts[J] ;
}
nzeros[K] = cost ;
}
}
}
#if MYDEBUG > 0
fprintf(stdout, "\n\n whoa, finished") ;
fflush(stdout) ;
#endif
/*
-------------------------------------------------
take the map from fronts to representative fronts
and make the map from old fronts to new fronts
-------------------------------------------------
*/
mapIV = IV_new() ;
IV_init(mapIV, nfront, NULL) ;
map = IV_entries(mapIV) ;
for ( J = 0, nnew = 0 ; J < nfront ; J++ ) {
if ( rep[J] == J ) {
map[J] = nnew++ ;
} else {
K = J ;
while ( rep[K] != K ) {
K = rep[K] ;
}
rep[J] = K ;
}
}
for ( J = 0 ; J < nfront ; J++ ) {
if ( (K = rep[J]) != J ) {
map[J] = map[K] ;
}
}
/*
-------------------------------
get the compressed ETree object
-------------------------------
*/
etree2 = ETree_compress(etree, mapIV) ;
/*
-------------------------
remap the nzeros[] vector
-------------------------
*/
temp = IVinit(nfront, 0) ;
IVcopy(nfront, temp, nzeros) ;
IV_setSize(nzerosIV, nnew) ;
nzeros = IV_entries(nzerosIV) ;
for ( J = 0 ; J < nfront ; J++ ) {
if ( rep[J] == J ) {
nzeros[map[J]] = temp[J] ;
}
}
IVfree(temp) ;
/*
------------------------
free the working storage
------------------------
*/
IVfree(nodwghts) ;
IVfree(rep) ;
IV_free(mapIV) ;
return(etree2) ; }
/*--------------------------------------------------------------------*/
int
main ( int argc, char *argv[] )
/*
-------------------------------------------------
1) read in graph
2) get the equivalence map
3) optionally write out equivalence map
4) get compressed graph
5) optionally write out compressed graph map
created -- 95mar02, cca
-------------------------------------------------
*/
{
char *inGraphFileName, *outIVfileName, *outGraphFileName ;
double t1, t2 ;
int coarseType, msglvl, rc ;
Graph *gc, *gf ;
FILE *msgFile ;
IV *mapIV ;
if ( argc != 7 ) {
fprintf(stdout,
"\n\n usage : %s msglvl msgFile inGraphFile "
"\n coarseType outMapFile outGraphFile"
"\n msglvl -- message level"
"\n msgFile -- message file"
"\n inGraphFile -- input file for graph"
"\n must be *.graphf or *.graphb"
"\n coarseType -- type for compressed graph"
"\n outMapFile -- output file for map vector"
"\n must be *.ivf or *.ivb"
"\n outGraphFile -- output file for compressed graph"
"\n must be *.graphf or *.graphb"
"\n", argv[0]) ;
return(0) ;
}
msglvl = atoi(argv[1]) ;
if ( strcmp(argv[2], "stdout") == 0 ) {
msgFile = stdout ;
} else if ( (msgFile = fopen(argv[2], "a")) == NULL ) {
fprintf(stderr, "\n fatal error in %s"
"\n unable to open file %s\n",
argv[0], argv[2]) ;
return(-1) ;
}
inGraphFileName = argv[3] ;
coarseType = atoi(argv[4]) ;
outIVfileName = argv[5] ;
outGraphFileName = argv[6] ;
fprintf(msgFile,
"\n %s "
"\n msglvl -- %d"
"\n msgFile -- %s"
"\n inGraphFile -- %s"
"\n coarseType -- %d"
"\n outMapFile -- %s"
"\n outGraphFile -- %s"
"\n",
argv[0], msglvl, argv[2], inGraphFileName,
coarseType, outIVfileName, outGraphFileName) ;
fflush(msgFile) ;
/*
------------------------
read in the Graph object
------------------------
*/
if ( strcmp(inGraphFileName, "none") == 0 ) {
fprintf(msgFile, "\n no file to read from") ;
exit(0) ;
}
MARKTIME(t1) ;
gf = Graph_new() ;
rc = Graph_readFromFile(gf, inGraphFileName) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : read in graph from file %s",
t2 - t1, inGraphFileName) ;
if ( rc != 1 ) {
fprintf(msgFile, "\n return value %d from Graph_readFromFile(%p,%s)",
rc, gf, inGraphFileName) ;
exit(-1) ;
}
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n after reading Graph object from file %s",
inGraphFileName) ;
Graph_writeForHumanEye(gf, msgFile) ;
fflush(msgFile) ;
} else {
Graph_writeStats(gf, msgFile) ;
fflush(msgFile) ;
}
/*
-----------------------
get the equivalence map
-----------------------
*/
MARKTIME(t1) ;
mapIV = Graph_equivMap(gf) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : create equivalence map", t2 - t1) ;
if ( msglvl > 1 ) {
fprintf(msgFile, "\n\n equivalence map IV object") ;
IV_writeForHumanEye(mapIV, msgFile) ;
fflush(msgFile) ;
}
/*
---------------------------
write out the map IV object
---------------------------
*/
if ( strcmp(outIVfileName, "none") != 0 ) {
MARKTIME(t1) ;
rc = IV_writeToFile(mapIV, outIVfileName) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : write map IV to file %s",
t2 - t1, outIVfileName) ;
if ( rc != 1 ) {
fprintf(msgFile, "\n return value %d from IV_writeToFile(%p,%s)",
rc, mapIV, outIVfileName) ;
}
}
/*
------------------------
get the compressed graph
------------------------
*/
MARKTIME(t1) ;
gc = Graph_compress(gf, IV_entries(mapIV), coarseType) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : compress the graph", t2 - t1) ;
fprintf(msgFile, "\n\n compressed graph") ;
if ( msglvl > 2 ) {
Graph_writeForHumanEye(gc, msgFile) ;
fflush(msgFile) ;
} else {
Graph_writeStats(gc, msgFile) ;
fflush(msgFile) ;
}
/*
--------------------------
write out the Graph object
--------------------------
*/
if ( strcmp(outGraphFileName, "none") != 0 ) {
MARKTIME(t1) ;
rc = Graph_writeToFile(gc, outGraphFileName) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : write compressed graph to file %s",
t2 - t1, outGraphFileName) ;
if ( rc != 1 ) {
fprintf(msgFile,
"\n return value %d from Graph_writeToFile(%p,%s)",
rc, gc, outGraphFileName) ;
exit(-1) ;
}
}
/*
----------------
free the objects
----------------
*/
Graph_free(gf) ;
Graph_free(gc) ;
IV_free(mapIV) ;
fprintf(msgFile, "\n") ;
fclose(msgFile) ;
return(1) ; }
/*
------------------------------------------------------------------
purpose -- to find indistinguishable nodes in the reach set
flag = 0 --> return
flag = 1 --> check out nodes that are 2-adj
flag = 2 --> check out nodes that are both 2-adj and not
note: the reach set is not changed.
created -- 96feb15, cca
modified -- 97feb07, cca
very tricky "bug"
was : sum += ip->val for subtrees
sum += IVsum(nvedge, vedges) for uncovered edges
now : sum += ip->val + 1 for subtrees
sum += IVsum(nvedge, vedges) + nvedge for uncovered edges
checksums were "wrong" due to vertex 0 adding nothing
to the checksum. beware 0-indexing.
------------------------------------------------------------------
*/
void
MSMD_findInodes (
MSMD *msmd,
MSMDinfo *info
) {
int first, flag, i, ierr, iv, iw, j, k, keepon, nlist,
nreach, nvedge, sum, vid, vchk, vcount, wid ;
int *chk, *list, *reach, *vedges, *wedges ;
IP *ip, *ipv, *ipw, *vsubtrees ;
MSMDvtx *v, *w ;
/*
---------------
check the input
---------------
*/
if ( msmd == NULL || info == NULL ) {
fprintf(stderr, "\n fatal error in MSMD_findInodes(%p,%p)"
"\n bad input\n", msmd, info) ;
exit(-1) ;
}
if ( (flag = info->compressFlag % 4) == 0 ) {
/*
---------------------------------------
no compression requested, simple return
---------------------------------------
*/
return ;
}
/*
---------------------------------
if the reach set is empty, return
---------------------------------
*/
if ( (nreach = IV_size(&msmd->reachIV)) == 0 ) {
return ;
}
/*
reach = msmd->reach ;
*/
reach = IV_entries(&msmd->reachIV) ;
if ( info->msglvl > 3 ) {
fprintf(info->msgFile, "\n inside MSMD_findInodes(%p)"
"\n reach(%d) :", msmd, nreach) ;
IVfp80(info->msgFile, nreach, reach, 10, &ierr);
fflush(info->msgFile) ;
}
/*
-------------------------------------------------------
load the front of the reach set with nodes to be tested
-------------------------------------------------------
*/
chk = IV_entries(&msmd->ivtmpIV) ;
list = reach ;
if ( flag == 1 ) {
/*
-------------------------------------------
work only with nodes adjacent to 2 subtrees
-------------------------------------------
*/
i = 0 ; j = nreach - 1 ;
while ( i <= j ) {
vid = list[i] ;
v = msmd->vertices + vid ;
if ( v->nadj != 0 || (ip = v->subtrees) == NULL
|| (ip = ip->next) == NULL || ip->next != NULL ) {
/*
--------------------------------
vertex is not 2-adj, swap to end
--------------------------------
*/
list[i] = list[j] ;
list[j] = vid ;
j-- ;
} else {
/*
--------------------------
vertex is 2-adj, keep here
--------------------------
*/
i++ ;
}
}
nlist = j + 1 ;
} else {
/*
---------------------------------
put all reached nodes in the list
---------------------------------
*/
nlist = nreach ;
}
if ( nlist == 0 ) {
return ;
}
/*
-----------------------------------------------------
compute the the checksums and count adjacent subtrees
for all vertices in the list
-----------------------------------------------------
*/
for ( k = 0 ; k < nlist ; k++ ) {
vid = list[k] ;
v = msmd->vertices + vid ;
vcount = 0 ;
sum = 0 ;
if ( info->msglvl > 4 ) {
fprintf(info->msgFile, "\n vertex %d", vid) ;
fflush(info->msgFile) ;
}
for ( ipv = v->subtrees ; ipv != NULL ; ipv = ipv->next ) {
/*
------------------------------------
add adjacent subtree to the checksum
------------------------------------
*/
sum += ipv->val + 1 ;
if ( info->msglvl > 4 ) {
fprintf(info->msgFile, "\n adjacent subtree %d, sum = %d",
ipv->val, sum) ;
fflush(info->msgFile) ;
}
vcount++ ;
}
if ( (nvedge = v->nadj) > 0 && (vedges = v->adj) != NULL ) {
sum += IVsum(nvedge, vedges) + nvedge ;
if ( info->msglvl > 4 ) {
fprintf(info->msgFile, "\n %d adjacent edges :",
nvedge) ;
IVfp80(info->msgFile, nvedge, vedges, 20, &ierr) ;
fprintf(info->msgFile, " : sum = %d", sum) ;
fflush(info->msgFile) ;
}
IVqsortUp(nvedge, vedges) ;
}
/*
-----------------
save the checksum
-----------------
*/
chk[k] = sum ;
}
if ( info->msglvl > 3 ) {
fprintf(info->msgFile, "\n before sort, list array") ;
fflush(info->msgFile) ;
IVfp80(info->msgFile, nlist, list, 80, &ierr) ;
fflush(info->msgFile) ;
fprintf(info->msgFile, "\n chk array") ;
fflush(info->msgFile) ;
IVfp80(info->msgFile, nlist, chk, 80, &ierr) ;
fflush(info->msgFile) ;
}
/*
-----------------------------------------------------
sort the vertices in the reach set by their checksums
-----------------------------------------------------
*/
IV2qsortUp(nlist, chk, list) ;
if ( info->msglvl > 3 ) {
fprintf(info->msgFile, "\n after sort, reach array") ;
IVfp80(info->msgFile, nlist, list, 80, &ierr) ;
fprintf(info->msgFile, "\n chk array") ;
IVfp80(info->msgFile, nlist, chk, 80, &ierr) ;
fflush(info->msgFile) ;
}
/*
----------------------------------------
detect and purge indistinguishable nodes
----------------------------------------
*/
for ( iv = 0 ; iv < nlist ; iv++ ) {
vid = list[iv] ;
v = msmd->vertices + vid ;
if ( v->status == 'I' ) {
/*
-----------------------------------------------------
vertex has been found indistinguishable, skip to next
-----------------------------------------------------
*/
continue ;
}
/*
---------------------------
test against other vertices
---------------------------
*/
vchk = chk[iv] ;
nvedge = v->nadj ;
vedges = v->adj ;
vsubtrees = v->subtrees ;
if ( info->msglvl > 3 ) {
fprintf(info->msgFile,
"\n checking out v = %d, vchk = %d, status = %c",
v->id, vchk, v->status) ;
fflush(info->msgFile) ;
}
/*
---------------------------------------------------
check v against all vertices with the same checksum
---------------------------------------------------
*/
if ( info->msglvl > 3 ) {
fprintf(info->msgFile, "\n checking out v = %d, status = %d",
v->id, v->stage) ;
fflush(info->msgFile) ;
}
first = 1 ;
for ( iw = iv + 1 ; iw < nlist && chk[iw] == vchk ; iw++ ) {
wid = reach[iw] ;
w = msmd->vertices + wid ;
if ( info->msglvl > 3 ) {
fprintf(info->msgFile,
"\n w = %d, status = %c, status = %d",
w->id, w->status, w->stage) ;
fflush(info->msgFile) ;
}
if ( w->status == 'I'
|| v->stage != w->stage
|| nvedge != w->nadj ) {
/*
------------------------------------
w has been found indistinguishable
or
v and w do not lie on the same stage
or
edge counts are not the same
------------------------------------
*/
continue ;
}
/*
----------------------------------------
w and v check out so far, check to see
if all vertices adjacent to w are marked
----------------------------------------
*/
if ( info->msglvl > 3 ) {
fprintf(info->msgFile,
"\n checking %d against %d", wid, vid) ;
fflush(info->msgFile) ;
}
/*
---------------------------------------------------------------
check to see if the subtree lists and edge lists are indentical
---------------------------------------------------------------
*/
info->stageInfo->ncheck++ ;
keepon = 1 ;
ipv = vsubtrees ;
ipw = w->subtrees ;
while ( ipv != NULL && ipw != NULL ) {
if ( ipv->val != ipw->val ) {
keepon = 0 ;
break ;
}
ipv = ipv->next ;
ipw = ipw->next ;
}
if ( keepon == 1 ) {
wedges = w->adj ;
for ( k = 0 ; k < nvedge ; k++ ) {
if ( vedges[k] != wedges[k] ) {
keepon = 0 ;
break ;
}
}
}
if ( keepon == 1 ) {
/*
---------------------------------------------
w and v are indistinguishable, merge w into v
---------------------------------------------
*/
if ( info->msglvl > 1 ) {
fprintf(info->msgFile,
"\n %d absorbs %d, wght = %d, status[%d] = %c",
v->id, w->id, w->wght, w->id, w->status) ;
fflush(info->msgFile) ;
}
v->wght += w->wght ;
w->wght = 0 ;
w->status = 'I' ;
w->nadj = 0 ;
w->adj = NULL ;
w->par = v ;
if ( (ipw = w->subtrees) != NULL ) {
while ( ipw->next != NULL ) {
ipw = ipw->next ;
}
ipw->next = msmd->freeIP ;
msmd->freeIP = ipw ;
w->subtrees = NULL ;
}
info->stageInfo->nindst++ ;
}
}
}
if ( info->msglvl > 4 ) {
fprintf(info->msgFile,
"\n MSMD_findInodes(%p), all done checking the nodes", msmd) ;
fflush(info->msgFile) ;
}
return ; }
/*--------------------------------------------------------------------*/
int
main ( int argc, char *argv[] )
/*
---------------------------------------------------
read in a Graph and a stages id IV object,
replace the stages IV object with wirebasket stages
created -- 97jul30, cca
---------------------------------------------------
*/
{
char *inCompidsFileName, *inGraphFileName, *outStagesIVfileName ;
double t1, t2 ;
Graph *graph ;
int msglvl, nvtx, radius, rc, v ;
int *compids, *stages ;
IV *compidsIV, *stagesIV ;
FILE *msgFile ;
if ( argc != 7 ) {
fprintf(stdout,
"\n\n usage : %s msglvl msgFile inGraphFile inStagesFile "
"\n outStagesFile radius"
"\n msglvl -- message level"
"\n msgFile -- message file"
"\n inGraphFile -- input file, must be *.graphf or *.graphb"
"\n inStagesFile -- output file, must be *.ivf or *.ivb"
"\n outStagesFile -- output file, must be *.ivf or *.ivb"
"\n radius -- radius to set the stage "
"\n of a separator vertex"
"\n", argv[0]) ;
return(0) ;
}
msglvl = atoi(argv[1]) ;
if ( strcmp(argv[2], "stdout") == 0 ) {
msgFile = stdout ;
} else if ( (msgFile = fopen(argv[2], "a")) == NULL ) {
fprintf(stderr, "\n fatal error in %s"
"\n unable to open file %s\n",
argv[0], argv[2]) ;
return(-1) ;
}
inGraphFileName = argv[3] ;
inCompidsFileName = argv[4] ;
outStagesIVfileName = argv[5] ;
radius = atoi(argv[6]) ;
fprintf(msgFile,
"\n %s "
"\n msglvl -- %d"
"\n msgFile -- %s"
"\n inGraphFile -- %s"
"\n inStagesFile -- %s"
"\n outStagesFile -- %s"
"\n radius -- %d"
"\n",
argv[0], msglvl, argv[2], inGraphFileName, inCompidsFileName,
outStagesIVfileName, radius) ;
fflush(msgFile) ;
/*
------------------------
read in the Graph object
------------------------
*/
if ( strcmp(inGraphFileName, "none") == 0 ) {
fprintf(msgFile, "\n no file to read from") ;
exit(0) ;
}
graph = Graph_new() ;
MARKTIME(t1) ;
rc = Graph_readFromFile(graph, inGraphFileName) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : read in graph from file %s",
t2 - t1, inGraphFileName) ;
if ( rc != 1 ) {
fprintf(msgFile, "\n return value %d from Graph_readFromFile(%p,%s)",
rc, graph, inGraphFileName) ;
exit(-1) ;
}
fprintf(msgFile, "\n\n after reading Graph object from file %s",
inGraphFileName) ;
if ( msglvl > 2 ) {
Graph_writeForHumanEye(graph, msgFile) ;
} else {
Graph_writeStats(graph, msgFile) ;
}
fflush(msgFile) ;
/*
---------------------
read in the IV object
---------------------
*/
if ( strcmp(inCompidsFileName, "none") == 0 ) {
fprintf(msgFile, "\n no file to read from") ;
exit(0) ;
}
compidsIV = IV_new() ;
MARKTIME(t1) ;
rc = IV_readFromFile(compidsIV, inCompidsFileName) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : read in compidsIV from file %s",
t2 - t1, inCompidsFileName) ;
if ( rc != 1 ) {
fprintf(msgFile, "\n return value %d from IV_readFromFile(%p,%s)",
rc, compidsIV, inCompidsFileName) ;
exit(-1) ;
}
fprintf(msgFile, "\n\n after reading IV object from file %s",
inCompidsFileName) ;
if ( msglvl > 2 ) {
IV_writeForHumanEye(compidsIV, msgFile) ;
} else {
IV_writeStats(compidsIV, msgFile) ;
}
fflush(msgFile) ;
IV_sizeAndEntries(compidsIV, &nvtx, &compids) ;
/*
----------------------------
convert to the stages vector
----------------------------
*/
stagesIV = IV_new() ;
IV_init(stagesIV, nvtx, NULL) ;
stages = IV_entries(stagesIV) ;
for ( v = 0 ; v < nvtx ; v++ ) {
if ( compids[v] == 0 ) {
stages[v] = 1 ;
} else {
stages[v] = 0 ;
}
}
/*
for ( v = 0 ; v < nvtx ; v++ ) {
if ( compids[v] == 0 ) {
stages[v] = 0 ;
} else {
stages[v] = 1 ;
}
}
*/
/*
-------------------------
get the wirebasket stages
-------------------------
*/
Graph_wirebasketStages(graph, stagesIV, radius) ;
IV_sizeAndEntries(stagesIV, &nvtx, &stages) ;
for ( v = 0 ; v < nvtx ; v++ ) {
if ( stages[v] == 2 ) {
stages[v] = 1 ;
} else if ( stages[v] > 2 ) {
stages[v] = 2 ;
}
}
fprintf(msgFile, "\n\n new stages IV object") ;
if ( msglvl > 2 ) {
IV_writeForHumanEye(stagesIV, msgFile) ;
} else {
IV_writeStats(stagesIV, msgFile) ;
}
fflush(msgFile) ;
/*
---------------------------
write out the stages object
---------------------------
*/
if ( strcmp(outStagesIVfileName, "none") != 0 ) {
MARKTIME(t1) ;
IV_writeToFile(stagesIV, outStagesIVfileName) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : write stagesIV to file %s",
t2 - t1, outStagesIVfileName) ;
if ( rc != 1 ) {
fprintf(msgFile,
"\n return value %d from IV_writeToFile(%p,%s)",
rc, stagesIV, outStagesIVfileName) ;
}
}
/*
------------------------
free the working storage
------------------------
*/
Graph_free(graph) ;
IV_free(stagesIV) ;
IV_free(compidsIV) ;
fprintf(msgFile, "\n") ;
fclose(msgFile) ;
return(1) ; }
/*--------------------------------------------------------------------*/
int
main ( int argc, char *argv[] )
/*
----------------------------------------
get statistics for a semi-implicit solve
created -- 97dec11, cca
----------------------------------------
*/
{
char *inGraphFileName, *inETreeFileName, *inMapFileName ;
double nA21, nL, nL11, nL22, nPhi, nV, t1, t2 ;
ETree *etree ;
int ii, inside, J, K, msglvl, nfront, nJ,
nvtx, rc, sizeJ, v, vsize, w ;
int *adjJ, *frontmap, *map, *nodwghts,
*vadj, *vtxToFront, *vwghts ;
IV *mapIV ;
IVL *symbfacIVL ;
Graph *graph ;
FILE *msgFile ;
Tree *tree ;
if ( argc != 6 ) {
fprintf(stdout,
"\n\n usage : %s msglvl msgFile GraphFile ETreeFile mapFile "
"\n msglvl -- message level"
"\n msgFile -- message file"
"\n GraphFile -- input graph file, must be *.graphf or *.graphb"
"\n ETreeFile -- input ETree file, must be *.etreef or *.etreeb"
"\n mapFile -- input map IV file, must be *.ivf or *.ivb"
"\n",
argv[0]) ;
return(0) ;
}
msglvl = atoi(argv[1]) ;
if ( strcmp(argv[2], "stdout") == 0 ) {
msgFile = stdout ;
} else if ( (msgFile = fopen(argv[2], "a")) == NULL ) {
fprintf(stderr, "\n fatal error in %s"
"\n unable to open file %s\n",
argv[0], argv[2]) ;
return(-1) ;
}
inGraphFileName = argv[3] ;
inETreeFileName = argv[4] ;
inMapFileName = argv[5] ;
fprintf(msgFile,
"\n %s "
"\n msglvl -- %d"
"\n msgFile -- %s"
"\n GraphFile -- %s"
"\n ETreeFile -- %s"
"\n mapFile -- %s"
"\n",
argv[0], msglvl, argv[2],
inGraphFileName, inETreeFileName, inMapFileName) ;
fflush(msgFile) ;
/*
------------------------
read in the Graph object
------------------------
*/
graph = Graph_new() ;
if ( strcmp(inGraphFileName, "none") == 0 ) {
fprintf(msgFile, "\n no file to read from") ;
exit(0) ;
}
MARKTIME(t1) ;
rc = Graph_readFromFile(graph, inGraphFileName) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : read in graph from file %s",
t2 - t1, inGraphFileName) ;
nvtx = graph->nvtx ;
vwghts = graph->vwghts ;
if ( rc != 1 ) {
fprintf(msgFile, "\n return value %d from Graph_readFromFile(%p,%s)",
rc, graph, inGraphFileName) ;
exit(-1) ;
}
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n after reading Graph object from file %s",
inGraphFileName) ;
Graph_writeForHumanEye(graph, msgFile) ;
fflush(msgFile) ;
}
/*
------------------------
read in the ETree object
------------------------
*/
etree = ETree_new() ;
if ( strcmp(inETreeFileName, "none") == 0 ) {
fprintf(msgFile, "\n no file to read from") ;
exit(0) ;
}
MARKTIME(t1) ;
rc = ETree_readFromFile(etree, inETreeFileName) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : read in etree from file %s",
t2 - t1, inETreeFileName) ;
nfront = ETree_nfront(etree) ;
tree = ETree_tree(etree) ;
vtxToFront = ETree_vtxToFront(etree) ;
nodwghts = ETree_nodwghts(etree) ;
nL = ETree_nFactorEntries(etree, 2) ;
if ( rc != 1 ) {
fprintf(msgFile, "\n return value %d from ETree_readFromFile(%p,%s)",
rc, etree, inETreeFileName) ;
exit(-1) ;
}
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n after reading ETree object from file %s",
inETreeFileName) ;
ETree_writeForHumanEye(etree, msgFile) ;
fflush(msgFile) ;
}
/*
-------------------------
read in the map IV object
-------------------------
*/
mapIV = IV_new() ;
if ( strcmp(inMapFileName, "none") == 0 ) {
fprintf(msgFile, "\n no file to read from") ;
exit(0) ;
}
MARKTIME(t1) ;
rc = IV_readFromFile(mapIV, inMapFileName) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %9.5f : read in mapIV from file %s",
t2 - t1, inMapFileName) ;
map = IV_entries(mapIV) ;
if ( rc != 1 ) {
fprintf(msgFile, "\n return value %d from IV_readFromFile(%p,%s)",
rc, mapIV, inMapFileName) ;
exit(-1) ;
}
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n after reading IV object from file %s",
inMapFileName) ;
IV_writeForHumanEye(mapIV, msgFile) ;
fflush(msgFile) ;
}
nV = nPhi = 0 ;
if ( vwghts == NULL ) {
for ( v = 0 ; v < nvtx ; v++ ) {
nV++ ;
if ( map[v] == 0 ) {
nPhi++ ;
}
}
} else {
for ( v = 0 ; v < nvtx ; v++ ) {
nV += vwghts[v] ;
if ( map[v] == 0 ) {
nPhi += vwghts[v] ;
}
}
}
fprintf(msgFile, "\n nPhi = %.0f, nV = %.0f", nPhi, nV) ;
/*
-------------------------
get the frontmap[] vector
-------------------------
*/
frontmap = IVinit(nfront, -1) ;
for ( v = 0 ; v < nvtx ; v++ ) {
J = vtxToFront[v] ;
if ( frontmap[J] == -1 ) {
frontmap[J] = map[v] ;
} else if ( frontmap[J] != map[v] ) {
fprintf(msgFile, "\n\n error, frontmap[%d] = %d, map[%d] = %d",
J, frontmap[J], v, map[v]) ;
}
}
/*
----------------------------------
compute the symbolic factorization
----------------------------------
*/
symbfacIVL = SymbFac_initFromGraph(etree, graph) ;
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n symbolic factorization") ;
IVL_writeForHumanEye(symbfacIVL, msgFile) ;
fflush(msgFile) ;
}
/*
--------------------------------------------
compute the number of entries in L11 and L22
--------------------------------------------
*/
nL11 = nL22 = 0 ;
for ( J = Tree_postOTfirst(tree) ;
J != -1 ;
J = Tree_postOTnext(tree, J) ) {
nJ = nodwghts[J] ;
if ( msglvl > 3 ) {
fprintf(msgFile, "\n\n front %d, nJ = %d", J, nJ) ;
}
IVL_listAndSize(symbfacIVL, J, &sizeJ, &adjJ) ;
for ( ii = 0, inside = 0 ; ii < sizeJ ; ii++ ) {
w = adjJ[ii] ;
K = vtxToFront[w] ;
if ( msglvl > 3 ) {
fprintf(msgFile, "\n w = %d, K = %d", w, K) ;
}
if ( K > J && frontmap[K] == frontmap[J] ) {
inside += (vwghts == NULL) ? 1 : vwghts[w] ;
if ( msglvl > 3 ) {
fprintf(msgFile, ", inside") ;
}
}
}
if ( frontmap[J] != 0 ) {
if ( msglvl > 3 ) {
fprintf(msgFile, "\n inside = %d, adding %d to L11",
inside, nJ*nJ + 2*nJ*inside) ;
}
nL11 += nJ*nJ + 2*nJ*inside ;
} else {
if ( msglvl > 3 ) {
fprintf(msgFile, "\n inside = %d, adding %d to L22",
inside, nJ*nJ + 2*nJ*inside) ;
}
nL22 += nJ*nJ + 2*nJ*inside ;
}
}
if ( msglvl > 0 ) {
fprintf(msgFile, "\n |L| = %.0f, |L11| = %.0f, |L22| = %.0f",
nL, nL11, nL22) ;
}
/*
------------------------------------
compute the number of entries in A21
------------------------------------
*/
nA21 = 0 ;
if ( vwghts != NULL ) {
for ( v = 0 ; v < nvtx ; v++ ) {
if ( map[v] == 0 ) {
Graph_adjAndSize(graph, v, &vsize, &vadj) ;
for ( ii = 0 ; ii < vsize ; ii++ ) {
w = vadj[ii] ;
if ( map[v] != map[w] ) {
if ( msglvl > 3 ) {
fprintf(msgFile, "\n A21 : v = %d, w = %d", v, w) ;
}
nA21 += vwghts[v] * vwghts[w] ;
}
}
}
}
} else {
for ( v = 0 ; v < nvtx ; v++ ) {
if ( map[v] == 0 ) {
Graph_adjAndSize(graph, v, &vsize, &vadj) ;
for ( ii = 0 ; ii < vsize ; ii++ ) {
w = vadj[ii] ;
if ( map[v] != map[w] ) {
if ( msglvl > 3 ) {
fprintf(msgFile, "\n A21 : v = %d, w = %d", v, w) ;
}
nA21++ ;
}
}
}
}
}
if ( msglvl > 0 ) {
fprintf(msgFile,
"\n |L| = %.0f, |L11| = %.0f, |L22| = %.0f, |A21| = %.0f",
nL, nL11, nL22, nA21) ;
fprintf(msgFile,
"\n storage: explicit = %.0f, semi-implicit = %.0f, ratio = %.3f"
"\n opcount: explicit = %.0f, semi-implicit = %.0f, ratio = %.3f",
nL, nL11 + nA21 + nL22,
nL/(nL11 + nA21 + nL22),
2*nL, 4*nL11 + 2*nA21 + 2*nL22,
2*nL/(4*nL11 + 2*nA21 + 2*nL22)) ;
fprintf(msgFile, "\n ratios %8.3f %8.3f %8.3f",
nPhi/nV,
nL/(nL11 + nA21 + nL22),
2*nL/(4*nL11 + 2*nA21 + 2*nL22)) ;
}
/*
------------------------
free the working storage
------------------------
*/
Graph_free(graph) ;
ETree_free(etree) ;
IV_free(mapIV) ;
IVL_free(symbfacIVL) ;
IVfree(frontmap) ;
fprintf(msgFile, "\n") ;
fclose(msgFile) ;
return(1) ; }
/*
------------------------------------------------
given a permutation and a vector to map vertices
into compressed vertices, create and return a
permutation object for the compressed vertices.
created -- 96may02, cca
------------------------------------------------
*/
Perm *
Perm_compress (
Perm *perm,
IV *eqmapIV
) {
int n, N, v, vcomp, vnew ;
int *eqmap, *head, *link, *newToOld, *oldToNew, *vals ;
Perm *perm2 ;
/*
---------------
check the input
---------------
*/
if ( perm == NULL
|| (n = perm->size) <= 0
|| eqmapIV == NULL
|| n != IV_size(eqmapIV)
|| (eqmap = IV_entries(eqmapIV)) == NULL ) {
fprintf(stderr, "\n fatal error in Perm_compress(%p,%p)"
"\n bad input\n", perm, eqmapIV) ;
if ( perm != NULL ) {
Perm_writeStats(perm, stderr) ;
}
if ( eqmapIV != NULL ) {
IV_writeStats(eqmapIV, stderr) ;
}
spoolesFatal();
}
n = perm->size ;
if ( (oldToNew = perm->oldToNew) == NULL ) {
Perm_fillOldToNew(perm) ;
oldToNew = perm->oldToNew ;
}
if ( (newToOld = perm->newToOld) == NULL ) {
Perm_fillNewToOld(perm) ;
newToOld = perm->newToOld ;
}
/*
---------------------------------
create the new permutation object
---------------------------------
*/
N = 1 + IVmax(n, eqmap, &v) ;
perm2 = Perm_new() ;
Perm_initWithTypeAndSize(perm2, 3, N) ;
/*
--------------------------------------------
get the head/link structure for the vertices
--------------------------------------------
*/
head = IVinit(N, -1) ;
link = IVinit(n, -1) ;
for ( v = 0 ; v < n ; v++ ) {
vcomp = eqmap[v] ;
link[v] = head[vcomp] ;
head[vcomp] = v ;
}
/*
---------------------------
get the two vectors to sort
---------------------------
*/
IVramp(N, perm2->newToOld, 0, 1) ;
vals = IVinit(N, -1) ;
for ( vcomp = 0 ; vcomp < N ; vcomp++ ) {
v = head[vcomp] ;
vnew = perm->oldToNew[v] ;
for ( v = link[v] ; v != -1 ; v = link[v] ) {
if ( vnew > perm->oldToNew[v] ) {
vnew = perm->oldToNew[v] ;
}
}
vals[vcomp] = vnew ;
}
IV2qsortUp(N, vals, perm2->newToOld) ;
for ( vcomp = 0 ; vcomp < N ; vcomp++ ) {
perm2->oldToNew[perm2->newToOld[vcomp]] = vcomp ;
}
/*
---------------------
free the working data
---------------------
*/
IVfree(head) ;
IVfree(link) ;
IVfree(vals) ;
return(perm2) ; }
/*
-----------------------
input a matrix
created -- 98jan28, cca
-----------------------
*/
static void
inputMatrix (
InpMtx *inpmtx,
int nrow,
int ncol,
int rowstride,
int colstride,
int rowind[],
int colind[],
double mtxent[]
) {
int col, ii, jj, kk, nent, row ;
int *ivec1, *ivec2 ;
prepareToAddNewEntries(inpmtx, nrow*ncol) ;
nent = inpmtx->nent ;
ivec1 = IV_entries(&inpmtx->ivec1IV) ;
ivec2 = IV_entries(&inpmtx->ivec2IV) ;
if ( INPMTX_IS_BY_ROWS(inpmtx) ) {
for ( jj = 0, kk = nent ; jj < ncol ; jj++ ) {
col = colind[jj] ;
for ( ii = 0 ; ii < nrow ; ii++, kk++ ) {
row = rowind[ii] ;
ivec1[kk] = row ;
ivec2[kk] = col ;
}
}
} else if ( INPMTX_IS_BY_COLUMNS(inpmtx) ) {
for ( jj = 0, kk = nent ; jj < ncol ; jj++ ) {
col = colind[jj] ;
for ( ii = 0 ; ii < nrow ; ii++, kk++ ) {
row = rowind[ii] ;
ivec1[kk] = col ;
ivec2[kk] = row ;
}
}
} else if ( INPMTX_IS_BY_CHEVRONS(inpmtx) ) {
for ( jj = 0, kk = nent ; jj < ncol ; jj++ ) {
col = colind[jj] ;
for ( ii = 0 ; ii < nrow ; ii++, kk++ ) {
row = rowind[ii] ;
if ( row <= col ) {
ivec1[kk] = row ;
} else {
ivec1[kk] = col ;
}
ivec2[kk] = col - row ;
}
}
}
IV_setSize(&inpmtx->ivec1IV, nent + nrow*ncol) ;
IV_setSize(&inpmtx->ivec2IV, nent + nrow*ncol) ;
if ( INPMTX_IS_REAL_ENTRIES(inpmtx) ) {
double *dvec = DV_entries(&inpmtx->dvecDV) ;
int ij ;
for ( jj = 0, kk = nent ; jj < ncol ; jj++ ) {
for ( ii = 0 ; ii < nrow ; ii++, kk++ ) {
ij = ii*rowstride + jj*colstride ;
dvec[kk] = mtxent[ij] ;
}
}
DV_setSize(&inpmtx->dvecDV, nent + nrow*ncol) ;
} if ( INPMTX_IS_COMPLEX_ENTRIES(inpmtx) ) {
double *dvec = DV_entries(&inpmtx->dvecDV) ;
int ij ;
for ( jj = 0, kk = nent ; jj < ncol ; jj++ ) {
for ( ii = 0 ; ii < nrow ; ii++, kk++ ) {
ij = ii*rowstride + jj*colstride ;
dvec[2*kk] = mtxent[2*ij] ;
dvec[2*kk+1] = mtxent[2*ij+1] ;
}
}
DV_setSize(&inpmtx->dvecDV, 2*(nent + nrow*ncol)) ;
}
inpmtx->nent += nrow*ncol ;
inpmtx->storageMode = INPMTX_RAW_DATA ;
return ; }
/*
-------------------------------------------------
draw a graph to an EPS file
(1) read a Graph object
(2) read a Coords object
(3) read an IV object that contains a tag vector.
if (v,w) is an edge in the graph
and tags[v] == tags[w] then
draw edge (v,w)
(4) bbox[4] is the bounding box for the plot.
bbox = { xsw, ysw, xne, yne }
try bbox = { 0, 0, 500, 500 }
because coordinates are measured in points,
72 points per inch.
(5) rect[4] contains the frame for the plot.
to put a 20 point margin around the plot,
rect[0] = bbox[0] + 20
rect[1] = bbox[1] + 20
rect[2] = bbox[2] - 20
rect[3] = bbox[3] - 20
created -- 98apr11, cca
-------------------------------------------------
*/
void
drawGraphEPS (
Graph *graph,
Coords *coords,
IV *tagsIV,
double bbox[],
double rect[],
double linewidth1,
double linewidth2,
double radius,
char *epsFileName,
int msglvl,
FILE *msgFile
) {
double a, b, d, height, offset, width,
xmax, xmin, xsize, xv, xw, x0, x1,
ymax, ymin, ysize, yv, yw, y0, y1 ;
FILE *epsFile ;
int ii, nedge, nvtx, v, vsize, w ;
int *tags, *vadj ;
nvtx = graph->nvtx ;
if ( tagsIV == NULL ) {
tags = NULL ;
} else {
tags = IV_entries(tagsIV) ;
}
/*
-----------------
open the EPS file
-----------------
*/
if ( strcmp(epsFileName, "stdout") == 0 ) {
epsFile = stdout ;
} else if ( (epsFile = fopen(epsFileName, "w")) == NULL ) {
fprintf(stderr, "\n fatal error in drawGraphEPS"
"\n unable to open file %s\n", epsFileName) ;
return ;
}
/*
-----------------------------------
write the preamble for the EPS file
-----------------------------------
*/
fprintf(epsFile,
"%%!PS-Adobe-2.0 EPSF-1.2"
"\n%%%%BoundingBox: %.1f %.1f %.1f %.1f",
bbox[0], bbox[1], bbox[2], bbox[3]) ;
fprintf(epsFile,
"\n /radius %.3f def"
"\n /Helvetica findfont %.3f scalefont setfont"
"\n /M {moveto} def"
"\n /L {lineto} def"
"\n /ACF { %% stack : x y radius"
"\n newpath 0 360 arc closepath fill "
"\n } def"
"\n /str 6 string def"
"\n /drawLabel { %% x y label radius"
"\n /radius exch def"
"\n /label exch def"
"\n /y exch def"
"\n /x exch def"
"\n gsave"
"\n 1.0 setgray"
"\n x radius add y moveto"
"\n x y radius 0 360 arc"
"\n fill"
"\n 0.0 setgray"
"\n x radius add y moveto"
"\n x y radius 0 360 arc"
"\n stroke"
"\n x y moveto"
"\n label stringwidth pop 2 div neg radius 2 div neg rmoveto"
"\n label show"
"\n grestore"
"\n } def ", radius, 1.25*radius) ;
/*
---------------------------------------
determine the transformation parameters
---------------------------------------
*/
xmin = Coords_min(coords, 1) ;
xmax = Coords_max(coords, 1) ;
ymin = Coords_min(coords, 2) ;
ymax = Coords_max(coords, 2) ;
if ( msglvl > 2 ) {
fprintf(msgFile,
"\n xmin = %.3g, xmax = %.3g, ymin = %.3g, ymax = %.3g",
xmin, xmax, ymin, ymax) ;
}
xsize = xmax - xmin ;
ysize = ymax - ymin ;
width = rect[2] - rect[0] ;
height = rect[3] - rect[1] ;
if ( msglvl > 2 ) {
fprintf(msgFile,
"\n xsize = %.3g, ysize = %.3g, width = %.3g, height = %.3g",
xsize, ysize, width, height) ;
}
if ( ysize * width <= xsize * height ) {
a = width / xsize ;
b = rect[0] ;
offset = (rect[3] - rect[1] - a * ysize)/2 ;
d = rect[1] + offset - a * ymin ;
} else {
a = height / ysize ;
d = rect[1] ;
offset = (rect[2] - rect[0] - a * xsize)/2 ;
b = rect[0] + offset - a * xmin ;
}
if ( ysize * width <= xsize * height ) {
a = width / xsize ;
} else {
a = height / ysize ;
}
b = 0.5*(rect[2] + rect[0] - a*(xmin + xmax)) ;
d = 0.5*(rect[3] + rect[1] - a*(ymin + ymax)) ;
if ( msglvl > 2 ) {
fprintf(msgFile, "\n width = %.3g, height = %.3g", width, height) ;
fprintf(msgFile, "\n xsize = %.3g, ysize = %.3g", xsize, ysize) ;
fprintf(msgFile,
"\n xmin = %.3g, xmax = %.3g, ymin = %.3g, ymax = %.3g",
xmin, xmax, ymin, ymax) ;
fprintf(msgFile, "\n a = %.3g, b = %.3g, d = %.3g", a, b, d) ;
}
if ( tags == NULL ) {
/*
--------------------------------
no component ids, draw the edges
--------------------------------
*/
fprintf(epsFile,
"\n gsave"
"\n %.3f setlinewidth"
"\n 0.0 setgray", linewidth1) ;
nedge = 0 ;
for ( v = 0 ; v < nvtx ; v++ ) {
Graph_adjAndSize(graph, v, &vsize, &vadj) ;
xv = Coords_value(coords, 1, v) ;
yv = Coords_value(coords, 2, v) ;
x0 = a * xv + b ;
y0 = a * yv + d ;
for ( ii = 0 ; ii < vsize ; ii++ ) {
w = vadj[ii] ;
if ( w < v ) {
xw = Coords_value(coords, 1, w) ;
yw = Coords_value(coords, 2, w) ;
x1 = a * xw + b ;
y1 = a * yw + d ;
if ( nedge % 100 == 0 ) {
fprintf(epsFile, "\n newpath") ;
}
fprintf(epsFile, "\n %.3g %.3g M %.3g %.3g L",
x0, y0, x1, y1) ;
if ( ++nedge % 100 == 0 ) {
fprintf(epsFile, "\n stroke") ;
}
}
}
}
if ( nedge % 100 != 0 ) {
fprintf(epsFile, "\n stroke") ;
}
fprintf(epsFile,
"\n grestore") ;
fprintf(epsFile,
"\n gsave"
"\n 0.1 setlinewidth"
"\n 0.0 setgray") ;
if ( radius > 0.0 ) {
/*
-----------------
draw the vertices
-----------------
*/
for ( v = 0 ; v < nvtx ; v++ ) {
xv = Coords_value(coords, 1, v) ;
yv = Coords_value(coords, 2, v) ;
x0 = a * xv + b ;
y0 = a * yv + d ;
fprintf(epsFile, "\n %.3f %.3f () radius drawLabel",
x0, y0) ;
}
}
fprintf(epsFile, "\n grestore") ;
} else {
/*
-----------------------------------------
component ids are present, draw the edges
between vertices in the same component
-----------------------------------------
*/
fprintf(epsFile,
"\n gsave"
"\n %.3f setlinewidth"
"\n 0.0 setgray", linewidth1) ;
nedge = 0 ;
for ( v = 0 ; v < nvtx ; v++ ) {
if ( tags[v] >= 0 ) {
Graph_adjAndSize(graph, v, &vsize, &vadj) ;
xv = Coords_value(coords, 1, v) ;
yv = Coords_value(coords, 2, v) ;
x0 = a * xv + b ;
y0 = a * yv + d ;
for ( ii = 0 ; ii < vsize ; ii++ ) {
w = vadj[ii] ;
if ( w < v && tags[w] == tags[v] ) {
xw = Coords_value(coords, 1, w) ;
yw = Coords_value(coords, 2, w) ;
x1 = a * xw + b ;
y1 = a * yw + d ;
if ( nedge % 100 == 0 ) {
fprintf(epsFile, "\n newpath") ;
}
fprintf(epsFile, "\n %.3g %.3g M %.3g %.3g L",
x0, y0, x1, y1) ;
if ( ++nedge % 100 == 0 ) {
fprintf(epsFile, "\n stroke") ;
}
}
}
}
}
if ( nedge % 100 != 0 ) {
fprintf(epsFile, "\n stroke") ;
}
fprintf(epsFile,
"\n grestore") ;
fprintf(epsFile,
"\n gsave"
"\n %.3f setlinewidth"
"\n 0.0 setgray", linewidth2) ;
nedge = 0 ;
for ( v = 0 ; v < nvtx ; v++ ) {
if ( tags[v] >= 0 ) {
Graph_adjAndSize(graph, v, &vsize, &vadj) ;
xv = Coords_value(coords, 1, v) ;
yv = Coords_value(coords, 2, v) ;
x0 = a * xv + b ;
y0 = a * yv + d ;
for ( ii = 0 ; ii < vsize ; ii++ ) {
w = vadj[ii] ;
if ( w < v && tags[w] != tags[v] && tags[w] >= 0 ) {
xw = Coords_value(coords, 1, w) ;
yw = Coords_value(coords, 2, w) ;
x1 = a * xw + b ;
y1 = a * yw + d ;
if ( nedge % 100 == 0 ) {
fprintf(epsFile, "\n newpath") ;
}
fprintf(epsFile, "\n %.3g %.3g M %.3g %.3g L",
x0, y0, x1, y1) ;
if ( ++nedge % 100 == 0 ) {
fprintf(epsFile, "\n stroke") ;
}
}
}
}
}
if ( nedge % 100 != 0 ) {
fprintf(epsFile, "\n stroke") ;
}
fprintf(epsFile,
"\n grestore") ;
fprintf(epsFile,
"\n gsave"
"\n 0.1 setlinewidth"
"\n 0.0 setgray") ;
if ( radius > 0.0 ) {
/*
-----------------
draw the vertices
-----------------
*/
for ( v = 0 ; v < nvtx ; v++ ) {
if ( tags[v] >= 0 ) {
xv = Coords_value(coords, 1, v) ;
yv = Coords_value(coords, 2, v) ;
x0 = a * xv + b ;
y0 = a * yv + d ;
fprintf(epsFile, "\n %.3f %.3f (%d) radius drawLabel",
x0, y0, tags[v]) ;
}
}
}
fprintf(epsFile, "\n grestore") ;
}
fprintf(epsFile, "\n showpage") ;
/*
----------------------------
close the file if not stdout
----------------------------
*/
if ( strcmp(epsFileName, "stdout") != 0 ) {
fclose(epsFile) ;
}
return ; }
/*
--------------------------------------------------------------------
purpose -- to fill submtx with a submatrix of the front matrix.
the fronts that form the submatrix are found in frontidsIV.
all information in submtx is local, front #'s are from 0 to
one less than the number of fronts in the submatrix, equation
#'s are from 0 to one less than the number of rows and columns
in the submatrix. the global row and column ids for the submatrix
are stored in rowsIV and colsIV on return.
return values ---
1 -- normal return
-1 -- submtx is NULL
-2 -- frontmtx is NULL
-3 -- frontmtx is not in 2-D mode
-4 -- frontidsIV is NULL
-5 -- frontidsIV is invalid
-6 -- rowsIV is NULL
-7 -- colsIV is NULL
-8 -- unable to create front tree
-9 -- unable to create symbfacIVL
-10 -- unable to create coladjIVL
-11 -- unable to create rowadjIVL
-12 -- unable to create upperblockIVL
-13 -- unable to create lowerblockIVL
created -- 98oct17, cca
--------------------------------------------------------------------
*/
int
FrontMtx_initFromSubmatrix (
FrontMtx *submtx,
FrontMtx *frontmtx,
IV *frontidsIV,
IV *rowsIV,
IV *colsIV,
int msglvl,
FILE *msgFile
) {
ETree *etreeSub ;
int ii, J, Jsub, K, Ksub, ncol, nfront, nfrontSub, neqnSub, nJ,
nrow, offset, rc, size, vSub ;
int *bndwghts, *colind, *colmap, *cols, *frontSubIds,
*list, *nodwghts, *rowind, *rowmap, *rows ;
IV *frontsizesIVsub, *vtxIV ;
IVL *coladjIVLsub, *lowerblockIVLsub, *rowadjIVLsub,
*symbfacIVLsub, *upperblockIVLsub ;
SubMtx *mtx ;
/*
---------------
check the input
---------------
*/
if ( submtx == NULL ) {
fprintf(stderr, "\n error in FrontMtx_initFromSubmatrix()"
"\n submtx is NULL\n") ;
return(-1) ;
}
if ( frontmtx == NULL ) {
fprintf(stderr, "\n error in FrontMtx_initFromSubmatrix()"
"\n frontmtx is NULL\n") ;
return(-2) ;
}
if ( ! FRONTMTX_IS_2D_MODE(frontmtx) ) {
fprintf(stderr, "\n error in FrontMtx_initFromSubmatrix()"
"\n frontmtx mode is not 2D\n") ;
return(-3) ;
}
if ( frontidsIV == NULL ) {
fprintf(stderr, "\n error in FrontMtx_initFromSubmatrix()"
"\n frontidsIV is NULL\n") ;
return(-4) ;
}
nfront = FrontMtx_nfront(frontmtx) ;
IV_sizeAndEntries(frontidsIV, &nfrontSub, &frontSubIds) ;
if ( nfrontSub < 0 || nfrontSub > nfront ) {
fprintf(stderr, "\n error in FrontMtx_initFromSubmatrix()"
"\n invalid frontidsIV"
"\n nfrontSub = %d, nfront %d\n", nfrontSub, nfront) ;
return(-5) ;
}
for ( ii = 0 ; ii < nfrontSub ; ii++ ) {
if ( (J = frontSubIds[ii]) < 0 || J >= nfront ) {
fprintf(stderr, "\n error in FrontMtx_initFromSubmatrix()"
"\n invalid frontidsIV"
"\n frontSubIds[%d] = %d, nfront = %d\n",
ii, J, nfront) ;
return(-5) ;
}
}
if ( rowsIV == NULL ) {
fprintf(stderr, "\n error in FrontMtx_initFromSubmatrix()"
"\n rowsIV is NULL\n") ;
return(-6) ;
}
if ( colsIV == NULL ) {
fprintf(stderr, "\n error in FrontMtx_initFromSubmatrix()"
"\n colsIV is NULL\n") ;
return(-7) ;
}
/*--------------------------------------------------------------------*/
/*
-----------------------------------------------------
clear the data for the submatrix and set the
scalar values (some inherited from the global matrix)
-----------------------------------------------------
*/
FrontMtx_clearData(submtx) ;
submtx->nfront = nfrontSub ;
submtx->type = frontmtx->type ;
submtx->symmetryflag = frontmtx->symmetryflag ;
submtx->sparsityflag = frontmtx->sparsityflag ;
submtx->pivotingflag = frontmtx->pivotingflag ;
submtx->dataMode = FRONTMTX_2D_MODE ;
/*
---------------------------------------------------------------
initialize the front tree for the submatrix.
note: on return, vtxIV is filled with the vertices originally
in the submatrix, (pivoting may change this), needed to find
symbolic factorization IVL object
note: at return, the boundary weights are likely to be invalid,
since we have no way of knowing what boundary indices for a
front are really in the domain. this will be changed after we
have the symbolic factorization.
---------------------------------------------------------------
*/
etreeSub = submtx->frontETree = ETree_new() ;
vtxIV = IV_new() ;
rc = ETree_initFromSubtree(etreeSub, frontidsIV,
frontmtx->frontETree, vtxIV) ;
if ( rc != 1 ) {
fprintf(stderr, "\n error in FrontMtx_initFromSubmatrix()"
"\n unable to create submatrix's front ETree, rc = %d\n", rc) ;
return(-8) ;
}
if ( msglvl > 4 ) {
fprintf(msgFile, "\n\n submatrix ETree") ;
ETree_writeForHumanEye(etreeSub, msgFile) ;
fprintf(msgFile, "\n\n submatrix original equations") ;
IV_writeForHumanEye(vtxIV, msgFile) ;
fflush(msgFile) ;
}
/*
------------------------------------------------------
set the # of equations (perhap temporarily if pivoting
has delayed some rows and columns), and the tree.
------------------------------------------------------
*/
submtx->neqns = neqnSub = IV_size(vtxIV) ;
submtx->tree = etreeSub->tree ;
/*
-----------------------------------------------------
initialize the symbolic factorization for the subtree
-----------------------------------------------------
*/
symbfacIVLsub = submtx->symbfacIVL = IVL_new() ;
rc = IVL_initFromSubIVL(symbfacIVLsub, frontmtx->symbfacIVL,
frontidsIV, vtxIV) ;
if ( rc != 1 ) {
fprintf(stderr, "\n error in FrontMtx_initFromSubmatrix()"
"\n unable to create submatrix's symbfac, rc = %d\n", rc) ;
return(-9) ;
}
if ( msglvl > 4 ) {
fprintf(msgFile, "\n\n submatrix symbolic factorizatio") ;
IVL_writeForHumanEye(symbfacIVLsub, msgFile) ;
fflush(msgFile) ;
}
/*
---------------------------------------------
adjust the boundary weights of the front tree
---------------------------------------------
*/
nodwghts = ETree_nodwghts(etreeSub) ;
bndwghts = ETree_bndwghts(etreeSub) ;
for ( J = 0 ; J < nfrontSub ; J++ ) {
IVL_listAndSize(symbfacIVLsub, J, &size, &list) ;
bndwghts[J] = size - nodwghts[J] ;
}
if ( msglvl > 4 ) {
fprintf(msgFile, "\n\n submatrix ETree after bndweight adjustment") ;
ETree_writeForHumanEye(etreeSub, msgFile) ;
fflush(msgFile) ;
}
/*
-------------------------------------
set the front sizes for the submatrix
-------------------------------------
*/
frontsizesIVsub = submtx->frontsizesIV = IV_new() ;
IV_init(frontsizesIVsub, nfrontSub, NULL) ;
IVgather(nfrontSub, IV_entries(frontsizesIVsub),
IV_entries(frontmtx->frontsizesIV),
IV_entries(frontidsIV)) ;
neqnSub = submtx->neqns = IV_sum(frontsizesIVsub) ;
if ( msglvl > 4 ) {
fprintf(msgFile, "\n\n %d equations in submatrix", neqnSub) ;
fprintf(msgFile, "\n\n front sizes for submatrix") ;
IV_writeForHumanEye(frontsizesIVsub, msgFile) ;
fflush(msgFile) ;
}
/*
-------------------------------------------------------------------
fill rowsIV and colsIV with the row and column ids of the submatrix
-------------------------------------------------------------------
*/
IV_setSize(rowsIV, neqnSub) ;
IV_setSize(colsIV, neqnSub) ;
rows = IV_entries(rowsIV) ;
cols = IV_entries(colsIV) ;
for ( Jsub = offset = 0 ; Jsub < nfrontSub ; Jsub++ ) {
if ( (nJ = FrontMtx_frontSize(submtx, Jsub)) > 0 ) {
J = frontSubIds[Jsub] ;
FrontMtx_columnIndices(frontmtx, J, &size, &list) ;
IVcopy(nJ, cols + offset, list) ;
FrontMtx_rowIndices(frontmtx, J, &size, &list) ;
IVcopy(nJ, rows + offset, list) ;
offset += nJ ;
}
}
if ( msglvl > 4 ) {
fprintf(msgFile, "\n\n row ids for submatrix") ;
IV_writeForHumanEye(rowsIV, msgFile) ;
fprintf(msgFile, "\n\n column ids for submatrix") ;
IV_writeForHumanEye(colsIV, msgFile) ;
fflush(msgFile) ;
}
/*
----------------------------------
get the row and column adjacencies
----------------------------------
*/
if ( FRONTMTX_IS_PIVOTING(frontmtx) ) {
submtx->neqns = neqnSub ;
coladjIVLsub = submtx->coladjIVL = IVL_new() ;
rc = IVL_initFromSubIVL(coladjIVLsub, frontmtx->coladjIVL,
frontidsIV, colsIV) ;
if ( rc != 1 ) {
fprintf(stderr, "\n error in FrontMtx_initFromSubmatrix()"
"\n unable to create submatrix's coladjIVL, rc = %d\n", rc) ;
return(-10) ;
}
if ( msglvl > 4 ) {
fprintf(msgFile, "\n\n submatrix col adjacency") ;
IVL_writeForHumanEye(coladjIVLsub, msgFile) ;
fflush(msgFile) ;
}
if ( FRONTMTX_IS_NONSYMMETRIC(frontmtx) ) {
rowadjIVLsub = submtx->rowadjIVL = IVL_new() ;
rc = IVL_initFromSubIVL(rowadjIVLsub, frontmtx->rowadjIVL,
frontidsIV, rowsIV) ;
if ( rc != 1 ) {
fprintf(stderr, "\n error in FrontMtx_initFromSubmatrix()"
"\n unable to create submatrix's rowadjIVL, rc = %d\n", rc) ;
return(-11) ;
}
if ( msglvl > 4 ) {
fprintf(msgFile, "\n\n submatrix row adjacency") ;
IVL_writeForHumanEye(rowadjIVLsub, msgFile) ;
fflush(msgFile) ;
}
}
}
IV_free(vtxIV) ;
/*
----------------------------------------------
get the rowmap[] and colmap[] vectors,
needed to translate indices in the submatrices
----------------------------------------------
*/
colmap = IVinit(frontmtx->neqns, -1) ;
for ( ii = 0 ; ii < neqnSub ; ii++ ) {
colmap[cols[ii]] = ii ;
}
if ( FRONTMTX_IS_NONSYMMETRIC(frontmtx) ) {
rowmap = IVinit(frontmtx->neqns, -1) ;
for ( ii = 0 ; ii < neqnSub ; ii++ ) {
rowmap[rows[ii]] = ii ;
}
} else {
rowmap = colmap ;
}
/*
-----------------------------------------------------------
get the upper and lower block IVL objects for the submatrix
-----------------------------------------------------------
*/
upperblockIVLsub = submtx->upperblockIVL = IVL_new() ;
rc = IVL_initFromSubIVL(upperblockIVLsub, frontmtx->upperblockIVL,
frontidsIV, frontidsIV) ;
if ( rc != 1 ) {
fprintf(stderr, "\n error in FrontMtx_initFromSubmatrix()"
"\n unable to create upperblockIVL, rc = %d\n", rc) ;
return(-12) ;
}
if ( msglvl > 4 ) {
fprintf(msgFile, "\n\n upper block adjacency IVL object") ;
IVL_writeForHumanEye(upperblockIVLsub, msgFile) ;
fflush(msgFile) ;
}
if ( FRONTMTX_IS_NONSYMMETRIC(frontmtx) ) {
lowerblockIVLsub = submtx->lowerblockIVL = IVL_new() ;
rc = IVL_initFromSubIVL(lowerblockIVLsub, frontmtx->lowerblockIVL,
frontidsIV, frontidsIV) ;
if ( rc != 1 ) {
fprintf(stderr, "\n error in FrontMtx_initFromSubmatrix()"
"\n unable to create lowerblockIVL, rc = %d\n", rc) ;
return(-13) ;
}
if ( msglvl > 4 ) {
fprintf(msgFile, "\n\n lower block adjacency IVL object") ;
IVL_writeForHumanEye(lowerblockIVLsub, msgFile) ;
fflush(msgFile) ;
}
}
/*
----------------------------------------------------------------
allocate the vector and hash table(s) for the factor submatrices
----------------------------------------------------------------
*/
ALLOCATE(submtx->p_mtxDJJ, struct _SubMtx *, nfrontSub) ;
for ( J = 0 ; J < nfrontSub ; J++ ) {
submtx->p_mtxDJJ[J] = NULL ;
}
submtx->upperhash = I2Ohash_new() ;
I2Ohash_init(submtx->upperhash, nfrontSub, nfrontSub, nfrontSub) ;
if ( FRONTMTX_IS_NONSYMMETRIC(frontmtx) ) {
submtx->lowerhash = I2Ohash_new() ;
I2Ohash_init(submtx->lowerhash, nfrontSub, nfrontSub, nfrontSub) ;
}
/*
-----------------------------------------------------------------
remove the diagonal submatrices from the factor matrix
and insert into the submatrix object. note: front row and column
ids must be changed to their local values, and the row and column
indices must be mapped to local indices.
-----------------------------------------------------------------
*/
for ( Jsub = 0 ; Jsub < nfrontSub ; Jsub++ ) {
J = frontSubIds[Jsub] ;
if ( (mtx = frontmtx->p_mtxDJJ[J]) != NULL ) {
SubMtx_setIds(mtx, Jsub, Jsub) ;
SubMtx_columnIndices(mtx, &ncol, &colind) ;
IVgather(ncol, colind, colmap, colind) ;
SubMtx_rowIndices(mtx, &nrow, &rowind) ;
IVgather(nrow, rowind, rowmap, rowind) ;
submtx->p_mtxDJJ[Jsub] = mtx ;
frontmtx->p_mtxDJJ[J] = NULL ;
submtx->nentD += mtx->nent ;
}
}
/*
----------------------------------------------------------------
remove the upper triangular submatrices from the factor matrix
and insert into the submatrix object. note: front row and column
ids must be changed to their local values. if the matrix is on
the diagonal, i.e., U(J,J), its row and column indices must be
mapped to local indices.
----------------------------------------------------------------
*/
for ( Jsub = 0 ; Jsub < nfrontSub ; Jsub++ ) {
J = frontSubIds[Jsub] ;
FrontMtx_upperAdjFronts(submtx, Jsub, &size, &list) ;
for ( ii = 0 ; ii < size ; ii++ ) {
Ksub = list[ii] ;
K = frontSubIds[Ksub] ;
if ( 1 == I2Ohash_remove(frontmtx->upperhash,
J, K, (void *) &mtx) ) {
SubMtx_setIds(mtx, Jsub, Ksub) ;
if ( K == J ) {
SubMtx_columnIndices(mtx, &ncol, &colind) ;
IVgather(ncol, colind, colmap, colind) ;
SubMtx_rowIndices(mtx, &nrow, &rowind) ;
IVgather(nrow, rowind, rowmap, rowind) ;
}
I2Ohash_insert(submtx->upperhash, Jsub, Ksub, (void *) mtx) ;
submtx->nentU += mtx->nent ;
}
}
}
if ( FRONTMTX_IS_NONSYMMETRIC(frontmtx) ) {
/*
----------------------------------------------------------------
remove the lower triangular submatrices from the factor matrix
and insert into the submatrix object. note: front row and column
ids must be changed to their local values. if the matrix is on
the diagonal, i.e., L(J,J), its row and column indices must be
mapped to local indices.
----------------------------------------------------------------
*/
for ( Jsub = 0 ; Jsub < nfrontSub ; Jsub++ ) {
J = frontSubIds[Jsub] ;
FrontMtx_lowerAdjFronts(submtx, Jsub, &size, &list) ;
for ( ii = 0 ; ii < size ; ii++ ) {
Ksub = list[ii] ;
K = frontSubIds[Ksub] ;
if ( 1 == I2Ohash_remove(frontmtx->lowerhash,
K, J, (void *) &mtx) ) {
SubMtx_setIds(mtx, Ksub, Jsub) ;
if ( K == J ) {
SubMtx_columnIndices(mtx, &ncol, &colind) ;
IVgather(ncol, colind, colmap, colind) ;
SubMtx_rowIndices(mtx, &nrow, &rowind) ;
IVgather(nrow, rowind, rowmap, rowind) ;
}
I2Ohash_insert(submtx->lowerhash, Ksub, Jsub, (void *) mtx);
submtx->nentL += mtx->nent ;
}
}
}
}
/*
------------------------
free the working storage
------------------------
*/
IVfree(colmap) ;
if ( FRONTMTX_IS_NONSYMMETRIC(frontmtx) ) {
IVfree(rowmap) ;
}
return(1) ; }
// 2008/03/12 kazuhide nakata
void Newton::initialize_sparse_bMat(int m, IV *newToOldIV,
IVL *symbfacIVL)
{
// bMat_type = SPARSE;
// printf("SPARSE computation\n");
int* newToOld;
newToOld = IV_entries(newToOldIV);
NewArray(ordering,int,m);
NewArray(reverse_ordering,int,m);
for (int i=0; i<m; i++){
ordering[i] = newToOld[i];
}
for (int i=0; i<m; i++){
reverse_ordering[ordering[i]] = i;
}
// separate front or back node
int* counter;
int nClique = IVL_nlist(symbfacIVL);
int psize;
int* pivec;
bool* bnode;
int* nFront;
NewArray(counter,int ,m);
NewArray(bnode ,bool,m);
NewArray(nFront ,int ,nClique);
for (int k=0; k<m; k++){
bnode[k] = false;
counter[k] = -1;
}
// search number of front
for (int l=nClique-1; l >= 0; l--){
IVL_listAndSize(symbfacIVL,l,&psize,&pivec);
int i;
for (i=0; i<psize; i++){
int ii = reverse_ordering[pivec[i]];
if (bnode[ii] == false){
counter[ii] = psize - i;
bnode[ii] = true;
} else {
nFront[l] = i;
break;
}
}
if (i == psize){
nFront[l] = psize;
}
}
// error check
for (int k=0; k<m; k++){
if (counter[k] == -1){
rError("Newton::initialize_sparse_bMat: program bug");
}
}
// make index of diagonal
NewArray(diagonalIndex,int,m+1);
diagonalIndex[0] = 0;
for (int k=1; k<m+1; k++){
diagonalIndex[k] = diagonalIndex[k-1] + counter[k-1];
}
// initialize sparse_bMat
sparse_bMat.initialize(m,m,SparseMatrix::SPARSE,diagonalIndex[m]);
// initialize index of sparse_bmat
int nonzeros = 0;
for (int l=0; l<nClique; l++){
IVL_listAndSize(symbfacIVL,l,&psize,&pivec);
for (int i=0; i<nFront[l]; i++){
int ii = reverse_ordering[pivec[i]];
for (int j=i; j<psize; j++){
int jj = reverse_ordering[pivec[j]];
int index = diagonalIndex[ii] + j - i;
sparse_bMat.row_index[index] = ii;
sparse_bMat.column_index[index] = jj;
nonzeros++;
}
}
}
// error check
if (nonzeros!= sparse_bMat.NonZeroNumber){
rError("Newton::initialize_sparse_bMat probram bug");
}
sparse_bMat.NonZeroCount = nonzeros;
// sparse_bMat.display();
DeleteArray(counter);
DeleteArray(bnode);
DeleteArray(nFront);
}
/*
-------------------------------------------------
clean the vertices in the reach set
for each v in reach set
clean subtree list
clean edge list
end for
created -- 95nov08, cca
-------------------------------------------------
*/
void
MSMD_cleanReachSet (
MSMD *msmd,
MSMDinfo *info
) {
int k, nreach ;
int *reach ;
MSMDvtx *v ;
/*
---------------
check the input
---------------
*/
if ( msmd == NULL || info == NULL ) {
fprintf(stderr, "\n inside MSMD_cleanReachSet(%p,%p)"
"\n bad input\n", msmd, info) ;
exit(-1) ;
}
nreach = IV_size(&msmd->reachIV) ;
reach = IV_entries(&msmd->reachIV) ;
/*
nreach = msmd->nreach ;
reach = msmd->reach ;
*/
if ( nreach < 0 || nreach > msmd->nvtx || reach == NULL ) {
fprintf(stderr, "\n inside MSMD_cleanReachSet(%p)"
"\n nreach = %d, reach = %p, nvtx = %d\n",
msmd, nreach, reach, msmd->nvtx) ;
exit(-1) ;
}
if ( info->msglvl >= 5 ) {
fprintf(info->msgFile, "\n inside MSMD_cleanReachSet(%p)", msmd) ;
fflush(info->msgFile) ;
}
/*
---------------------------------------------------------
clean the subtree lists of the vertices in the reach list
---------------------------------------------------------
*/
#if MYDEBUG > 0
fprintf(stdout, "\n nreach = %d", nreach) ;
for ( k = 0 ; k < nreach ; k++ ) {
v = msmd->vertices + reach[k] ;
fprintf(stdout, "\n <%d, %c, %c>", v->id, v->status, v->mark) ;
}
fflush(stdout) ;
#endif
for ( k = 0 ; k < nreach ; k++ ) {
v = msmd->vertices + reach[k] ;
#if MYDEBUG > 1
fprintf(stdout, "\n calling MSMD_cleanSubtreeList(%p,%d)",
msmd, v->id) ;
fflush(stdout) ;
#endif
MSMD_cleanSubtreeList(msmd, v, info) ;
}
/*
------------------------------------------------------
clean the edge lists of the vertices in the reach list
------------------------------------------------------
*/
for ( k = 0 ; k < nreach ; k++ ) {
v = msmd->vertices + reach[k] ;
#if MYDEBUG > 1
fprintf(stdout, "\n calling MSMD_cleanEdgeList(%p,%d)",
msmd, v->id) ;
fflush(stdout) ;
#endif
MSMD_cleanEdgeList(msmd, v, info) ;
}
if ( info->msglvl > 3 ) {
for ( k = 0 ; k < nreach ; k++ ) {
v = msmd->vertices + reach[k] ;
MSMDvtx_print(v, info->msgFile) ;
}
}
return ; }
/*--------------------------------------------------------------------*/
int
main ( int argc, char *argv[] )
/*
-----------------------------------------------------
test the factor method for a grid matrix
(0) read in matrix from source file
(1) conver data matrix to InpMtx object if necessary
(2) create Graph and ETree object if necessary
(3) read in/create an ETree object
(4) create a solution matrix object
(5) multiply the solution with the matrix
to get a right hand side matrix object
(6) factor the matrix
(7) solve the system
created -- 98dec30, jwu
-----------------------------------------------------
*/
{
char etreeFileName[80], mtxFileName[80], *cpt, rhsFileName[80],
srcFileName[80], ctemp[81], msgFileName[80], slnFileName[80] ;
Chv *chv, *rootchv ;
ChvManager *chvmanager ;
DenseMtx *mtxB, *mtxQ, *mtxX, *mtxZ ;
double one[2] = { 1.0, 0.0 } ;
FrontMtx *frontmtx ;
InpMtx *mtxA ;
SubMtxManager *mtxmanager ;
double cputotal, droptol, conv_tol, factorops ;
double cpus[9] ;
Drand drand ;
double nops, tau, t1, t2 ;
ETree *frontETree ;
Graph *graph ;
FILE *msgFile, *inFile ;
int error, loc, msglvl, neqns, nzf, iformat,
pivotingflag, rc, seed, sparsityflag, symmetryflag,
method[METHODS], type, nrhs, etreeflag ;
int stats[6] ;
int nnzA, Ik, itermax, zversion, iterout ;
IV *newToOldIV, *oldToNewIV ;
IVL *symbfacIVL ;
int i, j, k, m, n, imethod, maxdomainsize, maxzeros, maxsize;
int nouter,ninner ;
if ( argc != 2 ) {
fprintf(stdout,
"\n\n usage : %s inFile"
"\n inFile -- input filename"
"\n", argv[0]) ;
return(-1) ;
}
/* read input file */
inFile = fopen(argv[1], "r");
if (inFile == (FILE *)NULL) {
fprintf(stderr, "\n fatal error in %s: unable to open file %s\n",
argv[0], argv[1]) ;
return(-1) ;
}
for (i=0; i<METHODS; i++) method[i]=-1;
imethod=0;
k=0;
while (1) {
fgets(ctemp, 80, inFile);
if (ctemp[0] != '*') {
/*printf("l=%2d:%s\n", strlen(ctemp),ctemp);*/
if (strlen(ctemp)==80) {
fprintf(stderr, "\n fatal error in %s: input line contains more than "
"80 characters.\n",argv[0]);
exit(-1);
}
if (k==0) {
sscanf(ctemp, "%d", &iformat);
if (iformat < 0 || iformat > 2) {
fprintf(stderr, "\n fatal error in %s: "
"invalid source matrix format\n",argv[0]) ;
return(-1) ;
}
}
else if (k==1)
sscanf(ctemp, "%s", srcFileName);
else if (k==2)
sscanf(ctemp, "%s", mtxFileName);
else if (k==3) {
sscanf(ctemp, "%d", &etreeflag);
if (etreeflag < 0 || etreeflag > 4) {
fprintf(stderr, "\n fatal error in %s: "
"invalid etree file status\n",argv[0]) ;
return(-1) ;
}
}
else if (k==4)
sscanf(ctemp, "%s", etreeFileName);
else if (k==5)
sscanf(ctemp, "%s", rhsFileName);
else if (k==6)
sscanf(ctemp, "%s", slnFileName);
else if (k==7){
sscanf(ctemp, "%s", msgFileName);
if ( strcmp(msgFileName, "stdout") == 0 ) {
msgFile = stdout ;
}
else if ( (msgFile = fopen(msgFileName, "a")) == NULL ) {
fprintf(stderr, "\n fatal error in %s"
"\n unable to open file %s\n", argv[0], ctemp) ;
return(-1) ;
}
}
else if (k==8)
sscanf(ctemp, "%d %d %d %d %d %d",
&msglvl, &seed, &nrhs, &Ik, &itermax, &iterout);
else if (k==9)
sscanf(ctemp, "%d %d %d", &symmetryflag, &sparsityflag, &pivotingflag);
else if (k==10)
sscanf(ctemp, "%lf %lf %lf", &tau, &droptol, &conv_tol);
else if (k==11) {
/*
for (j=0; j<strlen(ctemp); j++) {
printf("j=%2d:%s",j,ctemp+j);
if (ctemp[j] == ' ' && ctemp[j+1] != ' ') {
sscanf(ctemp+j, "%d", method+imethod);
printf("method[%d]=%d\n",imethod,method[imethod]);
if (method[imethod] < 0) break;
imethod++;
}
}
*/
imethod = sscanf(ctemp,"%d %d %d %d %d %d %d %d %d %d",
method, method+1, method+2, method+3, method+4,
method+5, method+6, method+7, method+8, method+9);
/*printf("imethod=%d\n",imethod);*/
for (j=0; j<imethod; j++) {
/*printf("method[%d]=%d\n",j,method[j]);*/
if (method[j]<0) {
imethod=j;
break;
}
}
if (imethod == 0) {
fprintf(msgFile,"No method assigned in input file\n");
return(-1);
}
}
k++;
}
if (k==12) break;
}
fclose(inFile);
/* reset nrhs to 1 */
if (nrhs > 1) {
fprintf(msgFile,"*** Multiple right-hand-side vectors is not allowed yet.\n");
fprintf(msgFile,"*** nrhs is reset to 1.\n");
nrhs =1;
}
fprintf(msgFile,
"\n %s "
"\n srcFileName -- %s"
"\n mtxFileName -- %s"
"\n etreeFileName -- %s"
"\n rhsFileName -- %s"
"\n msglvl -- %d"
"\n seed -- %d"
"\n symmetryflag -- %d"
"\n sparsityflag -- %d"
"\n pivotingflag -- %d"
"\n tau -- %e"
"\n droptol -- %e"
"\n conv_tol -- %e"
"\n method -- ",
argv[0], srcFileName, mtxFileName, etreeFileName, rhsFileName,
msglvl, seed, symmetryflag, sparsityflag, pivotingflag,
tau, droptol, conv_tol) ;
for (k=0; k<imethod; k++)
fprintf(msgFile, "%d ", method[k]);
fprintf(msgFile, "\n ", method[k]);
fflush(msgFile) ;
/*
--------------------------------------
initialize the random number generator
--------------------------------------
*/
Drand_setDefaultFields(&drand) ;
Drand_init(&drand) ;
Drand_setSeed(&drand, seed) ;
/*Drand_setUniform(&drand, 0.0, 1.0) ;*/
Drand_setNormal(&drand, 0.0, 1.0) ;
/*
----------------------------------------------
read in or convert source to the InpMtx object
----------------------------------------------
*/
rc = 1;
if ( strcmp(srcFileName, "none") == 0 ) {
fprintf(msgFile, "\n no file to read from") ;
exit(-1) ;
}
mtxA = InpMtx_new() ;
MARKTIME(t1) ;
if (iformat == 0) { /* InpMtx source format */
rc = InpMtx_readFromFile(mtxA, srcFileName) ;
strcpy(mtxFileName, srcFileName);
if ( rc != 1 )
fprintf(msgFile, "\n return value %d from InpMtx_readFromFile(%p,%s)",
rc, mtxA, srcFileName) ;
}
else if (iformat == 1) { /* HBF source format */
rc = InpMtx_readFromHBfile(mtxA, srcFileName) ;
if ( rc != 1 )
fprintf(msgFile, "\n return value %d from InpMtx_readFromHBfile(%p,%s)",
rc, mtxA, srcFileName) ;
}
else { /* AIJ2 source format */
rc = InpMtx_readFromAIJ2file(mtxA, srcFileName) ;
if ( rc != 1 )
fprintf(msgFile, "\n return value %d from InpMtx_readFromAIJ2file(%p,%s)",
rc, mtxA, srcFileName) ;
}
MARKTIME(t2) ;
if (iformat>0 && strcmp(mtxFileName, "none") != 0 ) {
rc = InpMtx_writeToFile(mtxA, mtxFileName) ;
if ( rc != 1 )
fprintf(msgFile, "\n return value %d from InpMtx_writeToFile(%p,%s)",
rc, mtxA, mtxFileName) ;
}
fprintf(msgFile, "\n CPU %8.3f : read in (+ convert to) mtxA from file %s",
t2 - t1, mtxFileName) ;
if (rc != 1) {
goto end_read;
}
type = mtxA->inputMode ;
neqns = 1 + IVmax(mtxA->nent, InpMtx_ivec1(mtxA), &loc) ;
if ( INPMTX_IS_BY_ROWS(mtxA) ) {
fprintf(msgFile, "\n matrix coordinate type is rows") ;
} else if ( INPMTX_IS_BY_COLUMNS(mtxA) ) {
fprintf(msgFile, "\n matrix coordinate type is columns") ;
} else if ( INPMTX_IS_BY_CHEVRONS(mtxA) ) {
fprintf(msgFile, "\n matrix coordinate type is chevrons") ;
} else {
fprintf(msgFile, "\n\n, error, bad coordinate type") ;
rc=-1;
goto end_read;
}
if ( INPMTX_IS_RAW_DATA(mtxA) ) {
fprintf(msgFile, "\n matrix storage mode is raw data\n") ;
} else if ( INPMTX_IS_SORTED(mtxA) ) {
fprintf(msgFile, "\n matrix storage mode is sorted\n") ;
} else if ( INPMTX_IS_BY_VECTORS(mtxA) ) {
fprintf(msgFile, "\n matrix storage mode is by vectors\n") ;
} else {
fprintf(msgFile, "\n\n, error, bad storage mode") ;
rc=-1;
goto end_read;
}
if ( msglvl > 1 ) {
fprintf(msgFile, "\n\n after reading InpMtx object from file %s",
mtxFileName) ;
if ( msglvl == 2 ) {
InpMtx_writeStats(mtxA, msgFile) ;
} else {
InpMtx_writeForHumanEye(mtxA, msgFile) ;
}
fflush(msgFile) ;
}
/*
Get the nonzeros in matrix A and print it
*/
nnzA = InpMtx_nent( mtxA );
fprintf(msgFile, "\n\n Input matrix size %d NNZ %d",
neqns, nnzA) ;
/*
--------------------------------------------------------
generate the linear system
1. generate solution matrix and fill with random numbers
2. generate rhs matrix and fill with zeros
3. compute matrix-matrix multiply
--------------------------------------------------------
*/
MARKTIME(t1) ;
mtxX = DenseMtx_new() ;
DenseMtx_init(mtxX, type, 0, -1, neqns, nrhs, 1, neqns) ;
mtxB = DenseMtx_new() ;
if (strcmp(rhsFileName, "none")) {
rc = DenseMtx_readFromFile(mtxB, rhsFileName) ;
if ( rc != 1 )
fprintf(msgFile, "\n return value %d from DenseMtx_readFromFile(%p,%s)",
rc, mtxB, rhsFileName) ;
DenseMtx_zero(mtxX) ;
}
else {
DenseMtx_init(mtxB, type, 1, -1, neqns, nrhs, 1, neqns) ;
DenseMtx_fillRandomEntries(mtxX, &drand) ;
DenseMtx_zero(mtxB) ;
switch ( symmetryflag ) {
case SPOOLES_SYMMETRIC :
InpMtx_sym_mmm(mtxA, mtxB, one, mtxX) ;
break ;
case SPOOLES_HERMITIAN :
InpMtx_herm_mmm(mtxA, mtxB, one, mtxX) ;
break ;
case SPOOLES_NONSYMMETRIC :
InpMtx_nonsym_mmm(mtxA, mtxB, one, mtxX) ;
break ;
default :
break ;
}
}
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %8.3f : set up the solution and rhs ",
t2 - t1) ;
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n original mtxX") ;
DenseMtx_writeForHumanEye(mtxX, msgFile) ;
fprintf(msgFile, "\n\n original mtxB") ;
DenseMtx_writeForHumanEye(mtxB, msgFile) ;
fflush(msgFile) ;
}
if (rc != 1) {
InpMtx_free(mtxA);
DenseMtx_free(mtxX);
DenseMtx_free(mtxB);
goto end_init;
}
/*
------------------------
read in/create the ETree object
------------------------
*/
MARKTIME(t1) ;
if (etreeflag == 0) { /* read in ETree from file */
if ( strcmp(etreeFileName, "none") == 0 )
fprintf(msgFile, "\n no file to read from") ;
frontETree = ETree_new() ;
rc = ETree_readFromFile(frontETree, etreeFileName) ;
if (rc!=1)
fprintf(msgFile, "\n return value %d from ETree_readFromFile(%p,%s)",
rc, frontETree, etreeFileName) ;
}
else {
graph = Graph_new() ;
rc = InpMtx_createGraph(mtxA, graph);
if (rc!=1) {
fprintf(msgFile, "\n return value %d from InpMtx_createGraph(%p,%p)",
rc, mtxA, graph) ;
Graph_free(graph);
goto end_tree;
}
if (etreeflag == 1) { /* Via BestOfNDandMS */
maxdomainsize = 500; maxzeros = 1000; maxsize = 64 ;
frontETree = orderViaBestOfNDandMS(graph, maxdomainsize, maxzeros,
maxsize, seed, msglvl, msgFile) ;
}
else if (etreeflag == 2) { /* Via MMD */
frontETree = orderViaMMD(graph, seed, msglvl, msgFile) ;
}
else if (etreeflag == 3) { /* Via MS */
maxdomainsize = 500;
frontETree = orderViaMS(graph, maxdomainsize, seed, msglvl, msgFile) ;
}
else if (etreeflag == 4) { /* Via ND */
maxdomainsize = 500;
frontETree = orderViaND(graph, maxdomainsize, seed, msglvl, msgFile) ;
}
Graph_free(graph);
/* optionally write out the ETree object */
if ( strcmp(etreeFileName, "none") != 0 ) {
fprintf(msgFile, "\n\n writing out ETree to file %s",
etreeFileName) ;
ETree_writeToFile(frontETree, etreeFileName) ;
}
}
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %8.3f : read in/create frontETree from file %s",
t2 - t1, etreeFileName) ;
if ( rc != 1 ) {
ETree_free(frontETree);
goto end_tree;
}
ETree_leftJustify(frontETree) ;
if ( msglvl > 1 ) {
fprintf(msgFile, "\n\n after reading ETree object from file %s",
etreeFileName) ;
if ( msglvl == 2 ) {
ETree_writeStats(frontETree, msgFile) ;
} else {
ETree_writeForHumanEye(frontETree, msgFile) ;
}
}
fflush(msgFile) ;
/*
--------------------------------------------------
get the permutations, permute the matrix and the
front tree, and compute the symbolic factorization
--------------------------------------------------
*/
MARKTIME(t1) ;
oldToNewIV = ETree_oldToNewVtxPerm(frontETree) ;
newToOldIV = ETree_newToOldVtxPerm(frontETree) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %8.3f : get permutations", t2 - t1) ;
MARKTIME(t1) ;
ETree_permuteVertices(frontETree, oldToNewIV) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %8.3f : permute front tree", t2 - t1) ;
MARKTIME(t1) ;
InpMtx_permute(mtxA, IV_entries(oldToNewIV), IV_entries(oldToNewIV)) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %8.3f : permute mtxA", t2 - t1) ;
if ( symmetryflag == SPOOLES_SYMMETRIC
|| symmetryflag == SPOOLES_HERMITIAN ) {
MARKTIME(t1) ;
InpMtx_mapToUpperTriangle(mtxA) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %8.3f : map to upper triangle", t2 - t1) ;
}
if ( ! INPMTX_IS_BY_CHEVRONS(mtxA) ) {
MARKTIME(t1) ;
InpMtx_changeCoordType(mtxA, INPMTX_BY_CHEVRONS) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %8.3f : change coordinate type", t2 - t1) ;
}
if ( INPMTX_IS_RAW_DATA(mtxA) ) {
MARKTIME(t1) ;
InpMtx_changeStorageMode(mtxA, INPMTX_SORTED) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %8.3f : sort entries ", t2 - t1) ;
}
if ( INPMTX_IS_SORTED(mtxA) ) {
MARKTIME(t1) ;
InpMtx_changeStorageMode(mtxA, INPMTX_BY_VECTORS) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %8.3f : convert to vectors ", t2 - t1) ;
}
MARKTIME(t1) ;
symbfacIVL = SymbFac_initFromInpMtx(frontETree, mtxA) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %8.3f : symbolic factorization", t2 - t1) ;
MARKTIME(t1) ;
DenseMtx_permuteRows(mtxB, oldToNewIV) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %8.3f : permute rhs", t2 - t1) ;
/*
------------------------------
initialize the FrontMtx object
------------------------------
*/
MARKTIME(t1) ;
frontmtx = FrontMtx_new() ;
mtxmanager = SubMtxManager_new() ;
SubMtxManager_init(mtxmanager, NO_LOCK, 0) ;
FrontMtx_init(frontmtx, frontETree, symbfacIVL,
type, symmetryflag, sparsityflag, pivotingflag,
NO_LOCK, 0, NULL, mtxmanager, msglvl, msgFile) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n\n CPU %8.3f : initialize the front matrix",
t2 - t1) ;
if ( msglvl > 1 ) {
fprintf(msgFile,
"\n nendD = %d, nentL = %d, nentU = %d",
frontmtx->nentD, frontmtx->nentL, frontmtx->nentU) ;
SubMtxManager_writeForHumanEye(mtxmanager, msgFile) ;
}
if ( msglvl > 2 ) {
fprintf(msgFile, "\n front matrix initialized") ;
FrontMtx_writeForHumanEye(frontmtx, msgFile) ;
fflush(msgFile) ;
}
/*
-----------------
factor the matrix
-----------------
*/
nzf = ETree_nFactorEntries(frontETree, symmetryflag) ;
factorops = ETree_nFactorOps(frontETree, type, symmetryflag) ;
fprintf(msgFile,
"\n %d factor entries, %.0f factor ops, %8.3f ratio",
nzf, factorops, factorops/nzf) ;
IVzero(6, stats) ;
DVzero(9, cpus) ;
chvmanager = ChvManager_new() ;
ChvManager_init(chvmanager, NO_LOCK, 1) ;
MARKTIME(t1) ;
rootchv = FrontMtx_factorInpMtx(frontmtx, mtxA, tau, droptol,
chvmanager, &error, cpus,
stats, msglvl, msgFile) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n\n CPU %8.3f : factor matrix, %8.3f mflops",
t2 - t1, 1.e-6*factorops/(t2-t1)) ;
if ( rootchv != NULL ) {
fprintf(msgFile, "\n\n factorization did not complete") ;
for ( chv = rootchv ; chv != NULL ; chv = chv->next ) {
fprintf(stdout, "\n chv %d, nD = %d, nL = %d, nU = %d",
chv->id, chv->nD, chv->nL, chv->nU) ;
}
}
if ( error >= 0 ) {
fprintf(msgFile, "\n\n error encountered at front %d\n", error) ;
rc=error ;
goto end_front;
}
fprintf(msgFile,
"\n %8d pivots, %8d pivot tests, %8d delayed rows and columns",
stats[0], stats[1], stats[2]) ;
if ( frontmtx->rowadjIVL != NULL ) {
fprintf(msgFile,
"\n %d entries in rowadjIVL", frontmtx->rowadjIVL->tsize) ;
}
if ( frontmtx->coladjIVL != NULL ) {
fprintf(msgFile,
", %d entries in coladjIVL", frontmtx->coladjIVL->tsize) ;
}
if ( frontmtx->upperblockIVL != NULL ) {
fprintf(msgFile,
"\n %d fronts, %d entries in upperblockIVL",
frontmtx->nfront, frontmtx->upperblockIVL->tsize) ;
}
if ( frontmtx->lowerblockIVL != NULL ) {
fprintf(msgFile,
", %d entries in lowerblockIVL",
frontmtx->lowerblockIVL->tsize) ;
}
fprintf(msgFile,
"\n %d entries in D, %d entries in L, %d entries in U",
stats[3], stats[4], stats[5]) ;
fprintf(msgFile, "\n %d locks", frontmtx->nlocks) ;
if ( FRONTMTX_IS_SYMMETRIC(frontmtx)
|| FRONTMTX_IS_HERMITIAN(frontmtx) ) {
int nneg, npos, nzero ;
FrontMtx_inertia(frontmtx, &nneg, &nzero, &npos) ;
fprintf(msgFile,
"\n %d negative, %d zero and %d positive eigenvalues",
nneg, nzero, npos) ;
fflush(msgFile) ;
}
cputotal = cpus[8] ;
if ( cputotal > 0.0 ) {
fprintf(msgFile,
"\n initialize fronts %8.3f %6.2f"
"\n load original entries %8.3f %6.2f"
"\n update fronts %8.3f %6.2f"
"\n assemble postponed data %8.3f %6.2f"
"\n factor fronts %8.3f %6.2f"
"\n extract postponed data %8.3f %6.2f"
"\n store factor entries %8.3f %6.2f"
"\n miscellaneous %8.3f %6.2f"
"\n total time %8.3f",
cpus[0], 100.*cpus[0]/cputotal,
cpus[1], 100.*cpus[1]/cputotal,
cpus[2], 100.*cpus[2]/cputotal,
cpus[3], 100.*cpus[3]/cputotal,
cpus[4], 100.*cpus[4]/cputotal,
cpus[5], 100.*cpus[5]/cputotal,
cpus[6], 100.*cpus[6]/cputotal,
cpus[7], 100.*cpus[7]/cputotal, cputotal) ;
}
if ( msglvl > 1 ) {
SubMtxManager_writeForHumanEye(mtxmanager, msgFile) ;
ChvManager_writeForHumanEye(chvmanager, msgFile) ;
}
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n front factor matrix") ;
FrontMtx_writeForHumanEye(frontmtx, msgFile) ;
}
/*
------------------------------
post-process the factor matrix
------------------------------
*/
MARKTIME(t1) ;
FrontMtx_postProcess(frontmtx, msglvl, msgFile) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n\n CPU %8.3f : post-process the matrix", t2 - t1) ;
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n front factor matrix after post-processing") ;
FrontMtx_writeForHumanEye(frontmtx, msgFile) ;
}
fprintf(msgFile, "\n\n after post-processing") ;
if ( msglvl > 1 ) SubMtxManager_writeForHumanEye(frontmtx->manager, msgFile) ;
/*
----------------
solve the system
----------------
*/
neqns = mtxB->nrow ;
mtxZ = DenseMtx_new() ;
DenseMtx_init(mtxZ, type, 0, 0, neqns, nrhs, 1, neqns) ;
zversion=INPMTX_IS_COMPLEX_ENTRIES(mtxA);
for (k=0; k<imethod; k++) {
DenseMtx_zero(mtxZ) ;
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n rhs") ;
DenseMtx_writeForHumanEye(mtxB, msgFile) ;
fflush(stdout) ;
}
fprintf(msgFile, "\n\n itemax %d", itermax) ;
DVzero(6, cpus) ;
MARKTIME(t1) ;
switch ( method[k] ) {
case BiCGStabR :
if (zversion)
rc=zbicgstabr(neqns, type, symmetryflag, mtxA, frontmtx, mtxZ, mtxB,
itermax, conv_tol, msglvl, msgFile);
else
rc=bicgstabr(neqns, type, symmetryflag, mtxA, frontmtx, mtxZ, mtxB,
itermax, conv_tol, msglvl, msgFile);
break;
case BiCGStabL :
if (zversion)
rc=zbicgstabl(neqns, type, symmetryflag, mtxA, frontmtx, mtxZ, mtxB,
itermax, conv_tol, msglvl, msgFile);
else
rc=bicgstabl(neqns, type, symmetryflag, mtxA, frontmtx, mtxZ, mtxB,
itermax, conv_tol, msglvl, msgFile);
break;
case TFQMRR :
if (zversion)
rc=ztfqmrr(neqns, type, symmetryflag, mtxA, frontmtx, mtxZ, mtxB,
itermax, conv_tol, msglvl, msgFile);
else
rc=tfqmrr(neqns, type, symmetryflag, mtxA, frontmtx, mtxZ, mtxB,
itermax, conv_tol, msglvl, msgFile);
break;
case TFQMRL :
if (zversion)
rc=ztfqmrl(neqns, type, symmetryflag, mtxA, frontmtx, mtxZ, mtxB,
itermax, conv_tol, msglvl, msgFile);
else
rc=tfqmrl(neqns, type, symmetryflag, mtxA, frontmtx, mtxZ, mtxB,
itermax, conv_tol, msglvl, msgFile);
break;
case PCGR :
if (zversion)
rc=zpcgr(neqns, type, symmetryflag, mtxA, frontmtx, mtxZ, mtxB,
itermax, conv_tol, msglvl, msgFile);
else
rc=pcgr(neqns, type, symmetryflag, mtxA, frontmtx, mtxZ, mtxB,
itermax, conv_tol, msglvl, msgFile);
break;
case PCGL :
if (zversion)
rc=zpcgl(neqns, type, symmetryflag, mtxA, frontmtx, mtxZ, mtxB,
itermax, conv_tol, msglvl, msgFile);
else
rc=pcgl(neqns, type, symmetryflag, mtxA, frontmtx, mtxZ, mtxB,
itermax, conv_tol, msglvl, msgFile);
break;
case MLBiCGStabR :
mtxQ = DenseMtx_new() ;
DenseMtx_init(mtxQ, type, 0, -1, neqns, Ik, 1, neqns) ;
Drand_setUniform(&drand, 0.0, 1.0) ;
DenseMtx_fillRandomEntries(mtxQ, &drand) ;
if (zversion)
rc=zmlbicgstabr(neqns, type, symmetryflag, mtxA, frontmtx, mtxQ, mtxZ,
mtxB, itermax, conv_tol, msglvl, msgFile);
else
rc=mlbicgstabr(neqns, type, symmetryflag, mtxA, frontmtx, mtxQ, mtxZ,
mtxB, itermax, conv_tol, msglvl, msgFile);
DenseMtx_free(mtxQ) ;
break;
case MLBiCGStabL :
mtxQ = DenseMtx_new() ;
DenseMtx_init(mtxQ, type, 0, -1, neqns, Ik, 1, neqns) ;
Drand_setUniform(&drand, 0.0, 1.0) ;
DenseMtx_fillRandomEntries(mtxQ, &drand) ;
if (zversion)
rc=zmlbicgstabl(neqns, type, symmetryflag, mtxA, frontmtx, mtxQ, mtxZ,
mtxB, itermax, conv_tol, msglvl, msgFile);
else
rc=mlbicgstabl(neqns, type, symmetryflag, mtxA, frontmtx, mtxQ, mtxZ,
mtxB, itermax, conv_tol, msglvl, msgFile);
DenseMtx_free(mtxQ) ;
break;
case BGMRESR:
if (zversion)
fprintf(msgFile, "\n\n *** BGMRESR complex version is not available "
"at this moment. ") ;
else
rc=bgmresr(neqns, type, symmetryflag, mtxA, frontmtx, mtxZ,
mtxB, iterout, itermax, &nouter, &ninner, conv_tol,
msglvl, msgFile);
break;
case BGMRESL:
if (zversion)
fprintf(msgFile, "\n\n *** BGMRESR complex version is not available "
"at this moment. ") ;
else
rc=bgmresl(neqns, type, symmetryflag, mtxA, frontmtx, mtxZ,
mtxB, iterout, itermax, &nouter, &ninner, conv_tol,
msglvl, msgFile);
break;
default:
fprintf(msgFile, "\n\n *** Invalid method number ") ;
}
MARKTIME(t2) ;
fprintf(msgFile, "\n\n CPU %8.3f : solve the system", t2 - t1) ;
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n computed solution") ;
DenseMtx_writeForHumanEye(mtxZ, msgFile) ;
fflush(stdout) ;
}
/*
-------------------------------------------------------------
permute the computed solution back into the original ordering
-------------------------------------------------------------
*/
MARKTIME(t1) ;
DenseMtx_permuteRows(mtxZ, newToOldIV) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n CPU %8.3f : permute solution", t2 - t1) ;
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n permuted solution") ;
DenseMtx_writeForHumanEye(mtxZ, msgFile) ;
fflush(stdout) ;
}
/*
-------------
save solution
-------------
*/
if ( strcmp(slnFileName, "none") != 0 ) {
DenseMtx_writeToFile(mtxZ, slnFileName) ;
}
/*
-----------------
compute the error
-----------------
*/
if (!strcmp(rhsFileName, "none")) {
DenseMtx_sub(mtxZ, mtxX) ;
if (method[k] <8) {
mtxQ = DenseMtx_new() ;
DenseMtx_init(mtxQ, type, 0, -1, neqns, 1, 1, neqns) ;
rc=DenseMtx_initAsSubmatrix (mtxQ, mtxZ, 0, neqns-1, 0, 0);
fprintf(msgFile, "\n\n maxabs error = %12.4e", DenseMtx_maxabs(mtxQ)) ;
DenseMtx_free(mtxQ) ;
}
else
fprintf(msgFile, "\n\n maxabs error = %12.4e", DenseMtx_maxabs(mtxZ)) ;
if ( msglvl > 1 ) {
fprintf(msgFile, "\n\n error") ;
DenseMtx_writeForHumanEye(mtxZ, msgFile) ;
fflush(stdout) ;
}
if ( msglvl > 1 )
SubMtxManager_writeForHumanEye(frontmtx->manager, msgFile) ;
}
fprintf(msgFile, "\n--------- End of Method %d -------\n",method[k]) ;
}
/*
------------------------
free the working storage
------------------------
*/
DenseMtx_free(mtxZ) ;
end_front:
ChvManager_free(chvmanager) ;
SubMtxManager_free(mtxmanager) ;
FrontMtx_free(frontmtx) ;
IVL_free(symbfacIVL) ;
IV_free(oldToNewIV) ;
IV_free(newToOldIV) ;
end_tree:
ETree_free(frontETree) ;
end_init:
DenseMtx_free(mtxB) ;
DenseMtx_free(mtxX) ;
end_read:
InpMtx_free(mtxA) ;
fprintf(msgFile, "\n") ;
fclose(msgFile) ;
return(rc) ; }
/*
--------------------------------------------------------------
purpose -- to permute (if necessary) the original matrix,
and to initialize, factor and postprocess the factor matrix
return value ---
1 -- normal return, factorization complete
0 -- factorization did not complete, see error flag
-1 -- bridge is NULL
-2 -- mtxA is NULL
-3 -- perror is NULL
created -- 98sep18, cca
--------------------------------------------------------------
*/
int
BridgeMT_factor (
BridgeMT *bridge,
InpMtx *mtxA,
int permuteflag,
int *perror
) {
Chv *rootchv ;
ChvManager *chvmanager ;
double cputotal, nfops, t0, t1, t2 ;
double cpus[11] ;
int msglvl, nzf ;
int stats[16] ;
FILE *msgFile ;
FrontMtx *frontmtx ;
SubMtxManager *mtxmanager ;
/*--------------------------------------------------------------------*/
MARKTIME(t0) ;
/*
---------------
check the input
---------------
*/
if ( bridge == NULL ) {
fprintf(stderr, "\n error in BridgeMT_factor()"
"\n bridge is NULL\n") ;
return(-1) ;
}
if ( mtxA == NULL ) {
fprintf(stderr, "\n error in BridgeMT_factor()"
"\n mtxA is NULL\n") ;
return(-2) ;
}
if ( perror == NULL ) {
fprintf(stderr, "\n error in BridgeMT_factor()"
"\n perror is NULL\n") ;
return(-3) ;
}
msglvl = bridge->msglvl ;
msgFile = bridge->msgFile ;
/*--------------------------------------------------------------------*/
MARKTIME(t1) ;
if ( permuteflag == 1 ) {
int *oldToNew = IV_entries(bridge->oldToNewIV) ;
/*
------------------------------------------------
permute the input matrix and convert to chevrons
------------------------------------------------
*/
InpMtx_permute(mtxA, oldToNew, oldToNew) ;
if ( bridge->symmetryflag == SPOOLES_SYMMETRIC
|| bridge->symmetryflag == SPOOLES_HERMITIAN ) {
InpMtx_mapToUpperTriangle(mtxA) ;
}
}
if ( ! INPMTX_IS_BY_CHEVRONS(mtxA) ) {
InpMtx_changeCoordType(mtxA, INPMTX_BY_CHEVRONS) ;
}
if ( ! INPMTX_IS_BY_VECTORS(mtxA) ) {
InpMtx_changeStorageMode(mtxA, INPMTX_BY_VECTORS) ;
}
MARKTIME(t2) ;
bridge->cpus[6] += t2 - t1 ;
if ( msglvl > 1 ) {
fprintf(msgFile, "\n CPU %8.3f : permute and format A", t2 - t1) ;
fflush(msgFile) ;
}
/*
---------------------------
initialize the front matrix
---------------------------
*/
MARKTIME(t1) ;
if ( (mtxmanager = bridge->mtxmanager) == NULL ) {
mtxmanager = bridge->mtxmanager = SubMtxManager_new() ;
SubMtxManager_init(mtxmanager, LOCK_IN_PROCESS, 0) ;
}
if ( (frontmtx = bridge->frontmtx) == NULL ) {
frontmtx = bridge->frontmtx = FrontMtx_new() ;
} else {
FrontMtx_clearData(frontmtx) ;
}
FrontMtx_init(frontmtx, bridge->frontETree, bridge->symbfacIVL,
bridge->type, bridge->symmetryflag, bridge->sparsityflag,
bridge->pivotingflag, LOCK_IN_PROCESS, 0, NULL,
mtxmanager, msglvl, msgFile) ;
frontmtx->patchinfo = bridge->patchinfo ;
MARKTIME(t2) ;
bridge->cpus[7] += t2 - t1 ;
if ( msglvl > 1 ) {
fprintf(msgFile, "\n CPU %8.3f : initialize front matrix", t2 - t1) ;
fflush(msgFile) ;
}
/*
-----------------
factor the matrix
-----------------
*/
nzf = ETree_nFactorEntries(bridge->frontETree, bridge->symmetryflag) ;
nfops = ETree_nFactorOps(bridge->frontETree,
bridge->type, bridge->symmetryflag) ;
if ( msglvl > 1 ) {
fprintf(msgFile,
"\n %d factor entries, %.0f factor ops, %8.3f ratio",
nzf, nfops, nfops/nzf) ;
fflush(msgFile) ;
}
IVzero(16, stats) ;
DVzero(11, cpus) ;
chvmanager = ChvManager_new() ;
ChvManager_init(chvmanager, LOCK_IN_PROCESS, 1) ;
MARKTIME(t1) ;
rootchv = FrontMtx_MT_factorInpMtx(frontmtx, mtxA, bridge->tau,
bridge->droptol, chvmanager, bridge->ownersIV,
bridge->lookahead, perror, cpus, stats, msglvl, msgFile) ;
MARKTIME(t2) ;
IVcopy(6, bridge->stats, stats) ;
bridge->cpus[8] += t2 - t1 ;
if ( msglvl > 1 ) {
fprintf(msgFile, "\n\n CPU %8.3f : factor matrix, %8.3f mflops",
t2 - t1, 1.e-6*nfops/(t2-t1)) ;
fprintf(msgFile,
"\n %8d pivots, %8d pivot tests, %8d delayed vertices"
"\n %d entries in D, %d entries in L, %d entries in U",
stats[0], stats[1], stats[2], stats[3], stats[4], stats[5]) ;
cputotal = cpus[8] ;
if ( cputotal > 0.0 ) {
fprintf(msgFile,
"\n initialize fronts %8.3f %6.2f"
"\n load original entries %8.3f %6.2f"
"\n update fronts %8.3f %6.2f"
"\n assemble postponed data %8.3f %6.2f"
"\n factor fronts %8.3f %6.2f"
"\n extract postponed data %8.3f %6.2f"
"\n store factor entries %8.3f %6.2f"
"\n miscellaneous %8.3f %6.2f"
"\n total time %8.3f",
cpus[0], 100.*cpus[0]/cputotal,
cpus[1], 100.*cpus[1]/cputotal,
cpus[2], 100.*cpus[2]/cputotal,
cpus[3], 100.*cpus[3]/cputotal,
cpus[4], 100.*cpus[4]/cputotal,
cpus[5], 100.*cpus[5]/cputotal,
cpus[6], 100.*cpus[6]/cputotal,
cpus[7], 100.*cpus[7]/cputotal, cputotal) ;
}
}
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n submatrix mananger after factorization") ;
SubMtxManager_writeForHumanEye(mtxmanager, msgFile) ;
fprintf(msgFile, "\n\n chevron mananger after factorization") ;
ChvManager_writeForHumanEye(chvmanager, msgFile) ;
fflush(msgFile) ;
}
if ( msglvl > 3 ) {
fprintf(msgFile, "\n\n front factor matrix") ;
FrontMtx_writeForHumanEye(frontmtx, msgFile) ;
fflush(msgFile) ;
}
ChvManager_free(chvmanager) ;
if ( *perror >= 0 ) {
return(0) ;
}
/*
-----------------------------
post-process the front matrix
-----------------------------
*/
MARKTIME(t1) ;
FrontMtx_postProcess(frontmtx, msglvl, msgFile) ;
MARKTIME(t2) ;
bridge->cpus[9] += t2 - t1 ;
if ( msglvl > 1 ) {
fprintf(msgFile,
"\n\n CPU %8.3f : post-process the matrix", t2 - t1) ;
fflush(msgFile) ;
}
if ( msglvl > 2 ) {
fprintf(msgFile, "\n\n submatrix mananger after post-processing") ;
SubMtxManager_writeForHumanEye(frontmtx->manager, msgFile) ;
fflush(msgFile) ;
}
if ( msglvl > 3 ) {
fprintf(msgFile, "\n\n front factor matrix after post-processing") ;
FrontMtx_writeForHumanEye(frontmtx, msgFile) ;
fflush(msgFile) ;
}
/*--------------------------------------------------------------------*/
MARKTIME(t2) ;
bridge->cpus[10] += t2 - t0 ;
if ( msglvl > 1 ) {
fprintf(msgFile, "\n\n CPU %8.3f : total factor time", t2 - t0) ;
fflush(msgFile) ;
}
return(1) ; }
/*
--------------------------------------------------------------------
purpose -- merge the front tree allowing at most
maxzeros zero entries inside a front
return --
IV object that has the old front to new front map
created -- 96jun23, cca
modified -- 97dec18, cca
bug fixed that incorrectly counted the number of zeros in a front
--------------------------------------------------------------------
*/
ETree *
ETree_mergeFrontsAny (
ETree *etree,
int maxzeros,
IV *nzerosIV
) {
ETree *etree2 ;
int J, K, nfront, nvtx, nnew ;
int *bndwghts, *cost, *fch, *map, *nodwghts,
*nzeros, *par, *place, *rep, *sib, *temp ;
IV *mapIV ;
Tree *tree ;
/*
---------------
check the input
---------------
*/
if ( etree == NULL
|| (nfront = etree->nfront) <= 0
|| (nvtx = etree->nvtx) <= 0 ) {
fprintf(stderr, "\n fatal error in ETree_mergeFrontsAny(%p,%d)"
"\n bad input\n", etree, maxzeros) ;
spoolesFatal();
}
if ( IV_size(nzerosIV) != nfront ) {
fprintf(stderr, "\n fatal error in ETree_mergeFrontsAny(%p,%d,%p)"
"\n size(nzerosIV) = %d, nfront = %d\n",
etree, maxzeros, nzerosIV, IV_size(nzerosIV), nfront) ;
spoolesFatal();
}
nzeros = IV_entries(nzerosIV) ;
tree = etree->tree ;
nodwghts = IVinit(nfront, 0) ;
bndwghts = IVinit(nfront, 0) ;
par = IVinit(nfront, -1) ;
fch = IVinit(nfront, -1) ;
sib = IVinit(nfront, -1) ;
IVcopy(nfront, par, tree->par) ;
IVcopy(nfront, fch, tree->fch) ;
IVcopy(nfront, sib, tree->sib) ;
IVcopy(nfront, nodwghts, IV_entries(etree->nodwghtsIV)) ;
IVcopy(nfront, bndwghts, IV_entries(etree->bndwghtsIV)) ;
/*
----------------------
set up working storage
----------------------
*/
rep = IVinit(nfront, -1) ;
IVramp(nfront, rep, 0, 1) ;
cost = IVinit(nfront, 0) ;
/*
------------------------------------------
perform a post-order traversal of the tree
------------------------------------------
*/
for ( J = Tree_postOTfirst(tree) ;
J != -1 ;
J = Tree_postOTnext(tree, J) ) {
#if MYDEBUG > 0
fprintf(stdout, "\n\n ##### visiting front %d", J) ;
fflush(stdout) ;
#endif
visitAny(J, par, fch, sib, nodwghts, bndwghts,
rep, cost, nzeros, maxzeros) ;
}
#if MYDEBUG > 0
fprintf(stdout, "\n\n whoa, finished") ;
fflush(stdout) ;
#endif
/*
-------------------------------------------------
take the map from fronts to representative fronts
and make the map from old fronts to new fronts
-------------------------------------------------
*/
mapIV = IV_new() ;
IV_init(mapIV, nfront, NULL) ;
map = IV_entries(mapIV) ;
place = IVinit(nfront, -1) ;
for ( J = 0, nnew = 0 ; J < nfront ; J++ ) {
#if MYDEBUG > 0
fprintf(stdout, "\n rep[%d] = %d", J, rep[J]) ;
fflush(stdout) ;
#endif
if ( rep[J] != J ) {
K = J ;
while ( rep[K] != K ) {
#if MYDEBUG > 0
fprintf(stdout, "\n rep[%d] = %d", K, rep[K]) ;
fflush(stdout) ;
#endif
K = rep[K] ;
}
rep[J] = K ;
#if MYDEBUG > 0
fprintf(stdout, "\n setting rep[%d] = %d", J, rep[J]) ;
fflush(stdout) ;
#endif
} else {
place[J] = nnew++ ;
}
}
for ( J = 0 ; J < nfront ; J++ ) {
K = rep[J] ;
map[J] = place[K] ;
}
/*
-------------------------------
get the compressed ETree object
-------------------------------
*/
etree2 = ETree_compress(etree, mapIV) ;
/*
-------------------------
remap the nzeros[] vector
-------------------------
*/
temp = IVinit(nfront, 0) ;
IVcopy(nfront, temp, nzeros) ;
IV_setSize(nzerosIV, nnew) ;
nzeros = IV_entries(nzerosIV) ;
for ( J = 0 ; J < nfront ; J++ ) {
if ( rep[J] == J ) {
nzeros[map[J]] = temp[J] ;
}
}
IVfree(temp) ;
/*
------------------------
free the working storage
------------------------
*/
IVfree(par) ;
IVfree(fch) ;
IVfree(sib) ;
IVfree(nodwghts) ;
IVfree(bndwghts) ;
IVfree(rep) ;
IVfree(cost) ;
IVfree(place) ;
IV_free(mapIV) ;
return(etree2) ; }
/*
------------------------------------------------------------------
purpose -- return an ETree object for a nested dissection ordering
graph -- graph to order
maxdomainsize -- used to control the incomplete nested dissection
process. any subgraph whose weight is less than maxdomainsize
is not split further.
seed -- random number seed
msglvl -- message level, 0 --> no output, 1 --> timings
msgFile -- message file
created -- 97nov06, cca
------------------------------------------------------------------
*/
ETree *
orderViaND (
Graph *graph,
int maxdomainsize,
int seed,
int msglvl,
FILE *msgFile
) {
double t1, t2 ;
DSTree *dstree ;
ETree *etree ;
int nvtx, Nvtx ;
IV *eqmapIV, *stagesIV ;
/*
---------------
check the input
---------------
*/
if ( graph == NULL || maxdomainsize <= 0
|| (msglvl > 0 && msgFile == NULL) ) {
fprintf(stderr, "\n fatal error in orderViaND(%p,%d,%d,%d,%p)"
"\n bad input\n",
graph, maxdomainsize, seed, msglvl, msgFile) ;
spoolesFatal();
}
/*
------------------------------
compress the graph if worth it
------------------------------
*/
nvtx = graph->nvtx ;
MARKTIME(t1) ;
eqmapIV = Graph_equivMap(graph) ;
MARKTIME(t2) ;
if ( msglvl > 0 ) {
fprintf(msgFile, "\n CPU %8.3f : get equivalence map", t2 - t1) ;
fflush(msgFile) ;
}
Nvtx = 1 + IV_max(eqmapIV) ;
if ( Nvtx <= COMPRESS_FRACTION * nvtx ) {
MARKTIME(t1) ;
graph = Graph_compress2(graph, eqmapIV, 1) ;
MARKTIME(t2) ;
if ( msglvl > 0 ) {
fprintf(msgFile, "\n CPU %8.3f : compress graph", t2 - t1) ;
fflush(msgFile) ;
}
} else {
IV_free(eqmapIV) ;
eqmapIV = NULL ;
}
MARKTIME(t1) ;
IVL_sortUp(graph->adjIVL) ;
MARKTIME(t2) ;
if ( msglvl > 0 ) {
fprintf(msgFile, "\n CPU %8.3f : sort adjacency", t2 - t1) ;
fflush(msgFile) ;
}
/*
-----------------------------
get the domain separator tree
-----------------------------
*/
{
GPart *gpart ;
DDsepInfo *info ;
info = DDsepInfo_new() ;
info->seed = seed ;
info->maxcompweight = maxdomainsize ;
info->alpha = 0.1 ;
gpart = GPart_new() ;
GPart_init(gpart, graph) ;
GPart_setMessageInfo(gpart, msglvl, msgFile) ;
dstree = GPart_RBviaDDsep(gpart, info) ;
DSTree_renumberViaPostOT(dstree) ;
if ( msglvl > 0 ) {
DDsepInfo_writeCpuTimes(info, msgFile) ;
}
DDsepInfo_free(info) ;
GPart_free(gpart) ;
}
/*
---------------------
get the stages vector
---------------------
*/
stagesIV = DSTree_NDstages(dstree) ;
DSTree_free(dstree) ;
/*
---------------------------------------------
order the vertices and extract the front tree
---------------------------------------------
*/
{
MSMDinfo *info ;
MSMD *msmd ;
info = MSMDinfo_new() ;
info->seed = seed ;
info->compressFlag = 2 ;
info->msglvl = msglvl ;
info->msgFile = msgFile ;
msmd = MSMD_new() ;
MSMD_order(msmd, graph, IV_entries(stagesIV), info) ;
etree = MSMD_frontETree(msmd) ;
if ( msglvl > 0 ) {
MSMDinfo_print(info, msgFile) ;
}
MSMDinfo_free(info) ;
MSMD_free(msmd) ;
IV_free(stagesIV) ;
}
/*
-------------------------------------------------
expand the front tree if the graph was compressed
-------------------------------------------------
*/
if ( eqmapIV != NULL ) {
ETree *etree2 = ETree_expand(etree, eqmapIV) ;
ETree_free(etree) ;
etree = etree2 ;
Graph_free(graph) ;
IV_free(eqmapIV) ;
} else {
MARKTIME(t1) ;
IVL_sortUp(graph->adjIVL) ;
MARKTIME(t2) ;
if ( msglvl > 0 ) {
fprintf(msgFile, "\n CPU %8.3f : sort adjacency", t2 - t1) ;
fflush(msgFile) ;
}
}
return(etree) ; }
