int
HYPRE_IJVectorAssemble( HYPRE_IJVector vector )
{
hypre_IJVector *vec = (hypre_IJVector *) vector;
if (!vec)
{
printf("Variable vec is NULL -- HYPRE_IJVectorAssemble\n");
hypre_error_in_arg(1);
return hypre_error_flag;
}
/* if ( hypre_IJVectorObjectType(vec) == HYPRE_PETSC )
return( hypre_IJVectorAssemblePETSc(vec) );
else if ( hypre_IJVectorObjectType(vec) == HYPRE_ISIS )
return( hypre_IJVectorAssembleISIS(vec) );
else */ if ( hypre_IJVectorObjectType(vec) == HYPRE_PARCSR )
return( hypre_IJVectorAssemblePar(vec) );
else
{
printf("Unrecognized object type -- HYPRE_IJVectorAssemble\n");
hypre_error_in_arg(1);
}
return hypre_error_flag;
}
int
HYPRE_IJVectorSetMaxOffProcElmts( HYPRE_IJVector vector,
int max_off_proc_elmts)
{
hypre_IJVector *vec = (hypre_IJVector *) vector;
if (!vec)
{
printf("Variable vec is NULL -- HYPRE_IJVectorSetObjectType\n");
hypre_error_in_arg(1);
return hypre_error_flag;
}
/* if ( hypre_IJVectorObjectType(vec) == HYPRE_PETSC )
return( hypre_IJVectorSetMaxOffProcElmtsPETSc(vec,
max_off_proc_elmts));
else if ( hypre_IJVectorObjectType(vec) == HYPRE_ISIS )
return( hypre_IJVectorSetMaxOffProcElmtsISIS(vec,
max_off_proc_elmts));
else */ if ( hypre_IJVectorObjectType(vec) == HYPRE_PARCSR )
return( hypre_IJVectorSetMaxOffProcElmtsPar(vec,
max_off_proc_elmts));
else
{
printf("Unrecognized object type -- HYPRE_IJVectorGetValues\n");
hypre_error_in_arg(1);
}
return hypre_error_flag;
}
int
HYPRE_IJVectorPrint( HYPRE_IJVector vector,
const char *filename )
{
MPI_Comm comm = hypre_IJVectorComm(vector);
HYPRE_BigInt *partitioning;
HYPRE_BigInt jlower, jupper, j;
double value;
int myid;
char new_filename[255];
FILE *file;
if (!vector)
{
printf("Variable vec is NULL -- HYPRE_IJVectorPrint\n");
hypre_error_in_arg(1);
return hypre_error_flag;
}
MPI_Comm_rank(comm, &myid);
sprintf(new_filename,"%s.%05d", filename, myid);
if ((file = fopen(new_filename, "w")) == NULL)
{
printf("Error: can't open output file %s\n", new_filename);
hypre_error_in_arg(2);
return hypre_error_flag;
}
partitioning = hypre_IJVectorPartitioning(vector);
#ifdef HYPRE_NO_GLOBAL_PARTITION
jlower = partitioning[0];
jupper = partitioning[1] - 1;
#else
jlower = partitioning[myid];
jupper = partitioning[myid+1] - 1;
#endif
#ifdef HYPRE_LONG_LONG
fprintf(file, "%lld %lld\n", jlower, jupper);
#else
fprintf(file, "%d %d\n", jlower, jupper);
#endif
for (j = jlower; j <= jupper; j++)
{
HYPRE_IJVectorGetValues(vector, 1, &j, &value);
#ifdef HYPRE_LONG_LONG
fprintf(file, "%lld %.14e\n", j, value);
#else
fprintf(file, "%d %.14e\n", j, value);
#endif
}
fclose(file);
return hypre_error_flag;
}
int
HYPRE_IJVectorGetValues( HYPRE_IJVector vector,
int nvalues,
const HYPRE_BigInt *indices,
double *values )
{
hypre_IJVector *vec = (hypre_IJVector *) vector;
if (nvalues == 0) return hypre_error_flag;
if (!vec)
{
printf("Variable vec is NULL -- HYPRE_IJVectorGetValues\n");
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (nvalues < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
if (!indices)
{
hypre_error_in_arg(3);
return hypre_error_flag;
}
if (!values)
{
hypre_error_in_arg(4);
return hypre_error_flag;
}
/* if ( hypre_IJVectorObjectType(vec) == HYPRE_PETSC )
return( hypre_GetIJVectorPETScLocalComponents(vec, nvalues, indices, values) );
else if ( hypre_IJVectorObjectType(vec) == HYPRE_ISIS )
return( hypre_IJVectorGetValuesISIS(vec, nvalues, indices, values) );
else */ if ( hypre_IJVectorObjectType(vec) == HYPRE_PARCSR )
return( hypre_IJVectorGetValuesPar(vec, nvalues, indices, values) );
else
{
printf("Unrecognized object type -- HYPRE_IJVectorGetValues\n");
hypre_error_in_arg(1);
}
return hypre_error_flag;
}
HYPRE_Int hypre_AMEDestroy(void *esolver)
{
hypre_AMEData *ame_data = esolver;
hypre_AMSData *ams_data;
mv_InterfaceInterpreter* interpreter;
mv_MultiVectorPtr eigenvectors;
if (!ame_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
ams_data = ame_data -> precond;
interpreter = (mv_InterfaceInterpreter*) ame_data -> interpreter;
eigenvectors = (mv_MultiVectorPtr) ame_data -> eigenvectors;
if (!ams_data || !interpreter || !eigenvectors)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (ame_data -> G)
hypre_ParCSRMatrixDestroy(ame_data -> G);
if (ame_data -> A_G)
hypre_ParCSRMatrixDestroy(ame_data -> A_G);
if (ame_data -> B1_G)
HYPRE_BoomerAMGDestroy(ame_data -> B1_G);
if (ame_data -> B2_G)
HYPRE_ParCSRPCGDestroy(ame_data -> B2_G);
if (ame_data -> eigenvalues)
hypre_TFree(ame_data -> eigenvalues);
if (eigenvectors)
mv_MultiVectorDestroy(eigenvectors);
if (interpreter)
hypre_TFree(interpreter);
if (ams_data -> beta_is_zero)
{
if (ame_data -> t1)
hypre_ParVectorDestroy(ame_data -> t1);
if (ame_data -> t2)
hypre_ParVectorDestroy(ame_data -> t2);
}
if (ame_data)
hypre_TFree(ame_data);
/* Fields initialized using the Set functions are not destroyed */
return hypre_error_flag;
}
HYPRE_Int
HYPRE_ParCSRCGNRCreate( MPI_Comm comm, HYPRE_Solver *solver )
{
hypre_CGNRFunctions * cgnr_functions;
if (!solver)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
cgnr_functions =
hypre_CGNRFunctionsCreate(
hypre_ParKrylovCommInfo,
hypre_ParKrylovCreateVector,
hypre_ParKrylovDestroyVector, hypre_ParKrylovMatvecCreate,
hypre_ParKrylovMatvec, hypre_ParKrylovMatvecT,
hypre_ParKrylovMatvecDestroy,
hypre_ParKrylovInnerProd,
hypre_ParKrylovCopyVector, hypre_ParKrylovClearVector,
hypre_ParKrylovScaleVector, hypre_ParKrylovAxpy,
hypre_ParKrylovIdentitySetup,
hypre_ParKrylovIdentity, hypre_ParKrylovIdentity );
*solver = ( (HYPRE_Solver) hypre_CGNRCreate( cgnr_functions) );
return hypre_error_flag;
}
HYPRE_Int
HYPRE_ParCSRHybridCreate( HYPRE_Solver *solver )
{
*solver = ( (HYPRE_Solver) hypre_AMGHybridCreate( ) );
if (!solver) hypre_error_in_arg(1);
return hypre_error_flag;
}
HYPRE_Int
hypre_SysPFMGGetFinalRelativeResidualNorm( void *sys_pfmg_vdata,
HYPRE_Real *relative_residual_norm )
{
hypre_SysPFMGData *sys_pfmg_data = sys_pfmg_vdata;
HYPRE_Int max_iter = (sys_pfmg_data -> max_iter);
HYPRE_Int num_iterations = (sys_pfmg_data -> num_iterations);
HYPRE_Int logging = (sys_pfmg_data -> logging);
HYPRE_Real *rel_norms = (sys_pfmg_data -> rel_norms);
if (logging > 0)
{
if (max_iter == 0)
{
hypre_error_in_arg(1);
}
else if (num_iterations == max_iter)
{
*relative_residual_norm = rel_norms[num_iterations-1];
}
else
{
*relative_residual_norm = rel_norms[num_iterations];
}
}
return hypre_error_flag;
}
int
HYPRE_IJVectorGetLocalRange( HYPRE_IJVector vector, HYPRE_BigInt *jlower, HYPRE_BigInt *jupper )
{
hypre_IJVector *vec = (hypre_IJVector *) vector;
MPI_Comm comm;
HYPRE_BigInt *partitioning;
int my_id;
if (!vec)
{
printf("Variable vec is NULL -- HYPRE_IJVectorGetObjectType\n");
hypre_error_in_arg(1);
return hypre_error_flag;
}
comm = hypre_IJVectorComm(vec);
partitioning = hypre_IJVectorPartitioning(vec);
MPI_Comm_rank(comm, &my_id);
#ifdef HYPRE_NO_GLOBAL_PARTITION
*jlower = partitioning[0];
*jupper = partitioning[1]-1;
#else
*jlower = partitioning[my_id];
*jupper = partitioning[my_id+1]-1;
#endif
return hypre_error_flag;
}
HYPRE_Int
HYPRE_ParCSRGMRESCreate( MPI_Comm comm, HYPRE_Solver *solver )
{
hypre_GMRESFunctions * gmres_functions;
if (!solver)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
gmres_functions =
hypre_GMRESFunctionsCreate(
hypre_CAlloc, hypre_ParKrylovFree, hypre_ParKrylovCommInfo,
hypre_ParKrylovCreateVector,
hypre_ParKrylovCreateVectorArray,
hypre_ParKrylovDestroyVector, hypre_ParKrylovMatvecCreate,
hypre_ParKrylovMatvec, hypre_ParKrylovMatvecDestroy,
hypre_ParKrylovInnerProd, hypre_ParKrylovCopyVector,
hypre_ParKrylovClearVector,
hypre_ParKrylovScaleVector, hypre_ParKrylovAxpy,
hypre_ParKrylovIdentitySetup, hypre_ParKrylovIdentity );
*solver = ( (HYPRE_Solver) hypre_GMRESCreate( gmres_functions ) );
return hypre_error_flag;
}
HYPRE_Int
hypre_SStructInnerProd( hypre_SStructVector *x,
hypre_SStructVector *y,
double *result_ptr )
{
HYPRE_Int nparts = hypre_SStructVectorNParts(x);
double result;
double presult;
HYPRE_Int part;
HYPRE_Int x_object_type= hypre_SStructVectorObjectType(x);
HYPRE_Int y_object_type= hypre_SStructVectorObjectType(y);
if (x_object_type != y_object_type)
{
hypre_error_in_arg(2);
hypre_error_in_arg(3);
return hypre_error_flag;
}
result = 0.0;
if ( (x_object_type == HYPRE_SSTRUCT) || (x_object_type == HYPRE_STRUCT) )
{
for (part = 0; part < nparts; part++)
{
hypre_SStructPInnerProd(hypre_SStructVectorPVector(x, part),
hypre_SStructVectorPVector(y, part), &presult);
result += presult;
}
}
else if (x_object_type == HYPRE_PARCSR)
{
hypre_ParVector *x_par;
hypre_ParVector *y_par;
hypre_SStructVectorConvert(x, &x_par);
hypre_SStructVectorConvert(y, &y_par);
result= hypre_ParVectorInnerProd(x_par, y_par);
}
*result_ptr = result;
return hypre_error_flag;
}
int
HYPRE_IJVectorDestroy( HYPRE_IJVector vector )
{
hypre_IJVector *vec = (hypre_IJVector *) vector;
if (!vec)
{
printf("Vector variable is NULL -- HYPRE_IJVectorDestroy\n");
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (hypre_IJVectorPartitioning(vec))
hypre_TFree(hypre_IJVectorPartitioning(vec));
/* if ( hypre_IJVectorObjectType(vec) == HYPRE_PETSC )
ierr = hypre_IJVectorDestroyPETSc(vec) ;
else if ( hypre_IJVectorObjectType(vec) == HYPRE_ISIS )
ierr = hypre_IJVectorDestroyISIS(vec) ;
else */
if ( hypre_IJVectorObjectType(vec) == HYPRE_PARCSR )
{
hypre_IJVectorDestroyPar(vec) ;
if (hypre_IJVectorTranslator(vec))
{
hypre_AuxParVectorDestroy((hypre_AuxParVector *)
(hypre_IJVectorTranslator(vec)));
}
}
else if ( hypre_IJVectorObjectType(vec) != -1 )
{
printf("Unrecognized object type -- HYPRE_IJVectorDestroy\n");
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_TFree(vec);
return hypre_error_flag;
}
HYPRE_Int
HYPRE_IJMatrixGetRowCounts( HYPRE_IJMatrix matrix,
HYPRE_Int nrows,
HYPRE_Int *rows,
HYPRE_Int *ncols )
{
hypre_IJMatrix *ijmatrix = (hypre_IJMatrix *) matrix;
if (nrows == 0) return hypre_error_flag;
if (!ijmatrix)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (nrows < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
if (!rows)
{
hypre_error_in_arg(3);
return hypre_error_flag;
}
if (!ncols)
{
hypre_error_in_arg(4);
return hypre_error_flag;
}
if ( hypre_IJMatrixObjectType(ijmatrix) == HYPRE_PARCSR )
{
hypre_IJMatrixGetRowCountsParCSR( ijmatrix, nrows, rows, ncols );
}
else
{
hypre_error_in_arg(1);
}
return hypre_error_flag;
}
int
HYPRE_BoomerAMGCreate( HYPRE_Solver *solver)
{
*solver = (HYPRE_Solver) hypre_BoomerAMGCreate( ) ;
if (!solver)
hypre_error_in_arg(1);
return hypre_error_flag;
}
HYPRE_Int
HYPRE_SchwarzCreate( HYPRE_Solver *solver)
{
if (!solver)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*solver = (HYPRE_Solver) hypre_SchwarzCreate( ) ;
return hypre_error_flag;
}
HYPRE_Int
HYPRE_IJMatrixRead( const char *filename,
MPI_Comm comm,
HYPRE_Int type,
HYPRE_IJMatrix *matrix_ptr )
{
HYPRE_IJMatrix matrix;
HYPRE_Int ilower, iupper, jlower, jupper;
HYPRE_Int ncols, I, J;
HYPRE_Complex value;
HYPRE_Int myid, ret;
char new_filename[255];
FILE *file;
hypre_MPI_Comm_rank(comm, &myid);
hypre_sprintf(new_filename,"%s.%05d", filename, myid);
if ((file = fopen(new_filename, "r")) == NULL)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_fscanf(file, "%d %d %d %d", &ilower, &iupper, &jlower, &jupper);
HYPRE_IJMatrixCreate(comm, ilower, iupper, jlower, jupper, &matrix);
HYPRE_IJMatrixSetObjectType(matrix, type);
HYPRE_IJMatrixInitialize(matrix);
/* It is important to ensure that whitespace follows the index value to help
* catch mistakes in the input file. See comments in IJVectorRead(). */
ncols = 1;
while ( (ret = hypre_fscanf(file, "%d %d%*[ \t]%le", &I, &J, &value)) != EOF )
{
if (ret != 3)
{
hypre_error_w_msg(HYPRE_ERROR_GENERIC, "Error in IJ matrix input file.");
return hypre_error_flag;
}
if (I < ilower || I > iupper)
HYPRE_IJMatrixAddToValues(matrix, 1, &ncols, &I, &J, &value);
else
HYPRE_IJMatrixSetValues(matrix, 1, &ncols, &I, &J, &value);
}
HYPRE_IJMatrixAssemble(matrix);
fclose(file);
*matrix_ptr = matrix;
return hypre_error_flag;
}
HYPRE_Int
HYPRE_ParVectorInnerProd( HYPRE_ParVector x,
HYPRE_ParVector y,
HYPRE_Real *prod)
{
if (!x)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (!y)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
*prod = hypre_ParVectorInnerProd( (hypre_ParVector *) x,
(hypre_ParVector *) y) ;
return hypre_error_flag;
}
HYPRE_Int
hypre_ParVectorInitialize( hypre_ParVector *vector )
{
if (!vector)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_SeqVectorInitialize(hypre_ParVectorLocalVector(vector));
return hypre_error_flag;
}
/******************************************************************************
*
* hypre_IJVectorDistributePar
*
* takes an IJVector generated for one processor and distributes it
* across many processors according to vec_starts,
* if vec_starts is NULL, it distributes them evenly?
*
*****************************************************************************/
HYPRE_Int
hypre_IJVectorDistributePar(hypre_IJVector *vector,
const HYPRE_Int *vec_starts)
{
hypre_ParVector *old_vector = hypre_IJVectorObject(vector);
hypre_ParVector *par_vector;
HYPRE_Int print_level = hypre_IJVectorPrintLevel(vector);
if (!old_vector)
{
if (print_level)
{
hypre_printf("old_vector == NULL -- ");
hypre_printf("hypre_IJVectorDistributePar\n");
hypre_printf("**** Vector storage is either unallocated or orphaned ****\n");
}
hypre_error_in_arg(1);
}
par_vector = hypre_VectorToParVector(hypre_ParVectorComm(old_vector),
hypre_ParVectorLocalVector(old_vector),
(HYPRE_Int *)vec_starts);
if (!par_vector)
{
if (print_level)
{
hypre_printf("par_vector == NULL -- ");
hypre_printf("hypre_IJVectorDistributePar\n");
hypre_printf("**** Vector storage is unallocated ****\n");
}
hypre_error_in_arg(1);
}
hypre_ParVectorDestroy(old_vector);
hypre_IJVectorObject(vector) = par_vector;
return hypre_error_flag;
}
HYPRE_Int
hypre_SStructCopy( hypre_SStructVector *x,
hypre_SStructVector *y )
{
HYPRE_Int nparts = hypre_SStructVectorNParts(x);
HYPRE_Int part;
HYPRE_Int x_object_type= hypre_SStructVectorObjectType(x);
HYPRE_Int y_object_type= hypre_SStructVectorObjectType(y);
if (x_object_type != y_object_type)
{
hypre_error_in_arg(2);
hypre_error_in_arg(3);
return hypre_error_flag;
}
if (x_object_type == HYPRE_SSTRUCT)
{
for (part = 0; part < nparts; part++)
{
hypre_SStructPCopy(hypre_SStructVectorPVector(x, part),
hypre_SStructVectorPVector(y, part));
}
}
else if (x_object_type == HYPRE_PARCSR)
{
hypre_ParVector *x_par;
hypre_ParVector *y_par;
hypre_SStructVectorConvert(x, &x_par);
hypre_SStructVectorConvert(y, &y_par);
hypre_ParVectorCopy(x_par, y_par);
}
return hypre_error_flag;
}
hypre_ParVector *
hypre_ParVectorCreate( MPI_Comm comm,
HYPRE_Int global_size,
HYPRE_Int *partitioning)
{
hypre_ParVector *vector;
HYPRE_Int num_procs, my_id;
if (global_size < 0)
{
hypre_error_in_arg(2);
return NULL;
}
vector = hypre_CTAlloc(hypre_ParVector, 1);
hypre_MPI_Comm_rank(comm,&my_id);
if (!partitioning)
{
hypre_MPI_Comm_size(comm,&num_procs);
#ifdef HYPRE_NO_GLOBAL_PARTITION
hypre_GenerateLocalPartitioning(global_size, num_procs, my_id, &partitioning);
#else
hypre_GeneratePartitioning(global_size, num_procs, &partitioning);
#endif
}
hypre_ParVectorAssumedPartition(vector) = NULL;
hypre_ParVectorComm(vector) = comm;
hypre_ParVectorGlobalSize(vector) = global_size;
#ifdef HYPRE_NO_GLOBAL_PARTITION
hypre_ParVectorFirstIndex(vector) = partitioning[0];
hypre_ParVectorLastIndex(vector) = partitioning[1]-1;
hypre_ParVectorPartitioning(vector) = partitioning;
hypre_ParVectorLocalVector(vector) =
hypre_SeqVectorCreate(partitioning[1]-partitioning[0]);
#else
hypre_ParVectorFirstIndex(vector) = partitioning[my_id];
hypre_ParVectorLastIndex(vector) = partitioning[my_id+1] -1;
hypre_ParVectorPartitioning(vector) = partitioning;
hypre_ParVectorLocalVector(vector) =
hypre_SeqVectorCreate(partitioning[my_id+1]-partitioning[my_id]);
#endif
/* set defaults */
hypre_ParVectorOwnsData(vector) = 1;
hypre_ParVectorOwnsPartitioning(vector) = 1;
return vector;
}
HYPRE_Int
hypre_ParVectorSetDataOwner( hypre_ParVector *vector,
HYPRE_Int owns_data )
{
if (!vector)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParVectorOwnsData(vector) = owns_data;
return hypre_error_flag;
}
HYPRE_Int
HYPRE_IJMatrixAssemble( HYPRE_IJMatrix matrix )
{
hypre_IJMatrix *ijmatrix = (hypre_IJMatrix *) matrix;
if (!ijmatrix)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if ( hypre_IJMatrixObjectType(ijmatrix) == HYPRE_PARCSR )
{
return( hypre_IJMatrixAssembleParCSR( ijmatrix ) );
}
else
{
hypre_error_in_arg(1);
}
return hypre_error_flag;
}
HYPRE_Int
HYPRE_ParVectorRead( MPI_Comm comm,
const char *file_name,
HYPRE_ParVector *vector)
{
if (!vector)
{
hypre_error_in_arg(3);
return hypre_error_flag;
}
*vector = (HYPRE_ParVector) hypre_ParVectorRead( comm, file_name ) ;
return hypre_error_flag;
}
HYPRE_Int
HYPRE_IJMatrixInitialize( HYPRE_IJMatrix matrix )
{
hypre_IJMatrix *ijmatrix = (hypre_IJMatrix *) matrix;
HYPRE_Int ierr = 0;
if (!ijmatrix)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if ( hypre_IJMatrixObjectType(ijmatrix) == HYPRE_PARCSR )
ierr = hypre_IJMatrixInitializeParCSR( ijmatrix ) ;
else
{
hypre_error_in_arg(1);
}
return hypre_error_flag;
}
int
HYPRE_IJVectorRead( const char *filename,
MPI_Comm comm,
int type,
HYPRE_IJVector *vector_ptr )
{
HYPRE_IJVector vector;
HYPRE_BigInt jlower, jupper, j;
double value;
int myid;
char new_filename[255];
FILE *file;
MPI_Comm_rank(comm, &myid);
sprintf(new_filename,"%s.%05d", filename, myid);
if ((file = fopen(new_filename, "r")) == NULL)
{
printf("Error: can't open input file %s\n", new_filename);
hypre_error_in_arg(1);
return hypre_error_flag;
}
#ifdef HYPRE_LONG_LONG
fscanf(file, "%lld %lld", &jlower, &jupper);
#else
fscanf(file, "%d %d", &jlower, &jupper);
#endif
HYPRE_IJVectorCreate(comm, jlower, jupper, &vector);
HYPRE_IJVectorSetObjectType(vector, type);
HYPRE_IJVectorInitialize(vector);
#ifdef HYPRE_LONG_LONG
while ( fscanf(file, "%lld %le", &j, &value) != EOF )
#else
while ( fscanf(file, "%d %le", &j, &value) != EOF )
#endif
{
HYPRE_IJVectorSetValues(vector, 1, &j, &value);
}
HYPRE_IJVectorAssemble(vector);
fclose(file);
*vector_ptr = vector;
return hypre_error_flag;
}
int
HYPRE_IJVectorInitialize( HYPRE_IJVector vector )
{
hypre_IJVector *vec = (hypre_IJVector *) vector;
if (!vec)
{
printf("Vector variable is NULL -- HYPRE_IJVectorInitialize\n");
hypre_error_in_arg(1);
return hypre_error_flag;
}
/* if ( hypre_IJVectorObjectType(vec) == HYPRE_PETSC )
return( hypre_IJVectorInitializePETSc(vec) );
else if ( hypre_IJVectorObjectType(vec) == HYPRE_ISIS )
return( hypre_IJVectorInitializeISIS(vec) );
else */
if ( hypre_IJVectorObjectType(vec) == HYPRE_PARCSR )
{
if (!hypre_IJVectorObject(vec))
hypre_IJVectorCreatePar(vec, hypre_IJVectorPartitioning(vec));
hypre_IJVectorInitializePar(vec);
}
else
{
printf("Unrecognized object type -- HYPRE_IJVectorInitialize\n");
hypre_error_in_arg(1);
}
return hypre_error_flag;
}
HYPRE_Int
HYPRE_IJMatrixSetRowSizes( HYPRE_IJMatrix matrix,
const HYPRE_Int *sizes )
{
hypre_IJMatrix *ijmatrix = (hypre_IJMatrix *) matrix;
if (!ijmatrix)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if ( hypre_IJMatrixObjectType(ijmatrix) == HYPRE_PARCSR )
{
return( hypre_IJMatrixSetRowSizesParCSR( ijmatrix , sizes ) );
}
else
{
hypre_error_in_arg(1);
}
return hypre_error_flag;
}
HYPRE_Int
hypre_ParVectorSetPartitioningOwner( hypre_ParVector *vector,
HYPRE_Int owns_partitioning)
{
if (!vector)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParVectorOwnsPartitioning(vector) = owns_partitioning;
return hypre_error_flag;
}
HYPRE_Int
HYPRE_ParVectorCreate( MPI_Comm comm,
HYPRE_Int global_size,
HYPRE_Int *partitioning,
HYPRE_ParVector *vector )
{
if (!vector)
{
hypre_error_in_arg(4);
return hypre_error_flag;
}
*vector = (HYPRE_ParVector)
hypre_ParVectorCreate(comm, global_size, partitioning) ;
return hypre_error_flag;
}
