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_ParMultiVector *
hypre_ParMultiVectorTempRead(MPI_Comm comm, const char *fileName)
/* ***** temporary implementation ****** */
{
HYPRE_Int i, n, id;
double * dest;
double * src;
HYPRE_Int count;
HYPRE_Int retcode;
char temp_string[128];
hypre_ParMultiVector * x;
hypre_ParVector * temp_vec;
/* calculate the number of files */
hypre_MPI_Comm_rank( comm, &id );
n = 0;
do {
hypre_sprintf( temp_string, "test -f %s.%d.%d", fileName, n, id );
if (!(retcode=system(temp_string))) /* zero retcode mean file exists */
n++;
} while (!retcode);
if ( n == 0 ) return NULL;
/* now read the first vector using hypre_ParVectorRead into temp_vec */
hypre_sprintf(temp_string,"%s.%d",fileName,0);
temp_vec = hypre_ParVectorRead(comm, temp_string);
/* this vector WON'T own partitioning */
hypre_ParVectorSetPartitioningOwner(temp_vec,0);
/* now create multivector using temp_vec as a sample */
x = hypre_ParMultiVectorCreate(hypre_ParVectorComm(temp_vec),
hypre_ParVectorGlobalSize(temp_vec),hypre_ParVectorPartitioning(temp_vec),n);
/* this vector WILL own the partitioning */
hypre_ParMultiVectorSetPartitioningOwner(x,1);
hypre_ParMultiVectorInitialize(x);
/* read data from first and all other vectors into "x" */
i = 0;
do {
/* copy data from current vector */
dest = x->local_vector->data + i*(x->local_vector->size);
src = temp_vec->local_vector->data;
count = temp_vec->local_vector->size;
memcpy(dest,src, count*sizeof(double));
/* destroy current vector */
hypre_ParVectorDestroy(temp_vec);
/* read the data to new current vector, if there are more vectors to read */
if (i<n-1)
{
hypre_sprintf(temp_string,"%s.%d",fileName,i+1);
temp_vec = hypre_ParVectorRead(comm, temp_string);
}
} while (++i<n);
return x;
}
void*
hypre_ParReadVector( MPI_Comm comm, const char* file ) {
return (void*)hypre_ParVectorRead( comm, file );
}
HYPRE_Int
main( HYPRE_Int argc,
char *argv[] )
{
hypre_ParVector *vector1;
hypre_ParVector *vector2;
hypre_ParVector *tmp_vector;
HYPRE_Int num_procs, my_id;
HYPRE_Int global_size = 20;
HYPRE_Int local_size;
HYPRE_Int first_index;
HYPRE_Int i;
HYPRE_Int *partitioning;
HYPRE_Complex prod;
HYPRE_Complex *data, *data2;
hypre_Vector *vector;
hypre_Vector *local_vector;
hypre_Vector *local_vector2;
/* Initialize MPI */
hypre_MPI_Init(&argc, &argv);
hypre_MPI_Comm_size(hypre_MPI_COMM_WORLD, &num_procs );
hypre_MPI_Comm_rank(hypre_MPI_COMM_WORLD, &my_id );
hypre_printf(" my_id: %d num_procs: %d\n", my_id, num_procs);
partitioning = NULL;
vector1 = hypre_ParVectorCreate(hypre_MPI_COMM_WORLD,global_size,partitioning);
partitioning = hypre_ParVectorPartitioning(vector1);
hypre_ParVectorInitialize(vector1);
local_vector = hypre_ParVectorLocalVector(vector1);
data = hypre_VectorData(local_vector);
local_size = hypre_VectorSize(local_vector);
first_index = partitioning[my_id];
for (i=0; i < local_size; i++)
data[i] = first_index+i;
/*
hypre_ParVectorPrint(vector1, "Vector");
*/
local_vector2 = hypre_SeqVectorCreate(global_size);
hypre_SeqVectorInitialize(local_vector2);
data2 = hypre_VectorData(local_vector2);
for (i=0; i < global_size; i++)
data2[i] = i+1;
/* partitioning = hypre_CTAlloc(HYPRE_Int,4);
partitioning[0] = 0;
partitioning[1] = 10;
partitioning[2] = 10;
partitioning[3] = 20;
*/
vector2 = hypre_VectorToParVector(hypre_MPI_COMM_WORLD,local_vector2,partitioning);
hypre_ParVectorSetPartitioningOwner(vector2,0);
hypre_ParVectorPrint(vector2, "Convert");
vector = hypre_ParVectorToVectorAll(vector2);
/*-----------------------------------------------------------
* Copy the vector into tmp_vector
*-----------------------------------------------------------*/
tmp_vector = hypre_ParVectorRead(hypre_MPI_COMM_WORLD, "Convert");
/*
tmp_vector = hypre_ParVectorCreate(hypre_MPI_COMM_WORLD,global_size,partitioning);
hypre_ParVectorSetPartitioningOwner(tmp_vector,0);
hypre_ParVectorInitialize(tmp_vector);
hypre_ParVectorCopy(vector1, tmp_vector);
hypre_ParVectorPrint(tmp_vector,"Copy");
*/
/*-----------------------------------------------------------
* Scale tmp_vector
*-----------------------------------------------------------*/
hypre_ParVectorScale(2.0, tmp_vector);
/*
hypre_ParVectorPrint(tmp_vector,"Scale");
*/
/*-----------------------------------------------------------
* Do an Axpy (2*vector - vector) = vector
*-----------------------------------------------------------*/
hypre_ParVectorAxpy(-1.0, vector1, tmp_vector);
/*
hypre_ParVectorPrint(tmp_vector,"Axpy");
*/
/*-----------------------------------------------------------
* Do an inner product vector* tmp_vector
*-----------------------------------------------------------*/
prod = hypre_ParVectorInnerProd(vector1, tmp_vector);
hypre_printf (" prod: %8.2f \n", prod);
/*-----------------------------------------------------------
* Finalize things
*-----------------------------------------------------------*/
hypre_ParVectorDestroy(vector1);
hypre_ParVectorDestroy(vector2);
hypre_ParVectorDestroy(tmp_vector);
hypre_SeqVectorDestroy(local_vector2);
if (vector) hypre_SeqVectorDestroy(vector);
/* Finalize MPI */
hypre_MPI_Finalize();
return 0;
}
