source: CIVL/examples/mpi-omp/AMG2013/IJ_mv/HYPRE_IJVector.c

main
Last change on this file was ea777aa, checked in by Alex Wilton <awilton@…>, 3 years ago

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

git-svn-id: ​svn://vsl.cis.udel.edu/civl/trunk@5704 fb995dde-84ed-4084-dfe6-e5aef3e2452c
  • Property mode set to 100644
File size: 17.4 KB
Line 
1/*BHEADER**********************************************************************
2 * Copyright (c) 2008, Lawrence Livermore National Security, LLC.
3 * Produced at the Lawrence Livermore National Laboratory.
4 * This file is part of HYPRE. See file COPYRIGHT for details.
5 *
6 * HYPRE is free software; you can redistribute it and/or modify it under the
7 * terms of the GNU Lesser General Public License (as published by the Free
8 * Software Foundation) version 2.1 dated February 1999.
9 *
10 * $Revision: 2.4 $
11 ***********************************************************************EHEADER*/
12
13
14
15/******************************************************************************
16 *
17 * HYPRE_IJVector interface
18 *
19 *****************************************************************************/
20
21#include "./IJ_mv.h"
22
23#include "../HYPRE.h"
24
25/*--------------------------------------------------------------------------
26 * HYPRE_IJVectorCreate
27 *--------------------------------------------------------------------------*/
28
29int HYPRE_IJVectorCreate( MPI_Comm comm,
30 HYPRE_BigInt jlower,
31 HYPRE_BigInt jupper,
32 HYPRE_IJVector *vector )
33{
34 hypre_IJVector *vec;
35 int num_procs, my_id;
36 HYPRE_BigInt *partitioning;
37
38#ifdef HYPRE_NO_GLOBAL_PARTITION
39 HYPRE_BigInt row0, rowN;
40#else
41 HYPRE_BigInt *recv_buf;
42 HYPRE_BigInt *info;
43 int i, i2;
44#endif
45
46 vec = hypre_CTAlloc(hypre_IJVector, 1);
47
48 if (!vec)
49 {
50 printf("Out of memory -- HYPRE_IJVectorCreate\n");
51 hypre_error(HYPRE_ERROR_MEMORY);
52 return hypre_error_flag;
53 }
54
55 MPI_Comm_size(comm, &num_procs);
56 MPI_Comm_rank(comm, &my_id);
57
58 if (jlower > jupper+1 || jlower < 0)
59 {
60 hypre_error_in_arg(2);
61 return hypre_error_flag;
62 }
63 if (jupper < -1)
64 {
65 hypre_error_in_arg(3);
66 return hypre_error_flag;
67 }
68
69
70#ifdef HYPRE_NO_GLOBAL_PARTITION
71
72 partitioning = hypre_CTAlloc(HYPRE_BigInt, 2);
73
74 partitioning[0] = jlower;
75 partitioning[1] = jupper+1;
76
77
78 /* now we need the global number of rows as well
79 as the global first row index */
80
81 /* proc 0 has the first row */
82 if (my_id==0)
83 {
84 row0 = jlower;
85 }
86 MPI_Bcast(&row0, 1, MPI_HYPRE_BIG_INT, 0, comm);
87 /* proc (num_procs-1) has the last row */
88 if (my_id == (num_procs-1))
89 {
90 rowN = jupper;
91 }
92 MPI_Bcast(&rowN, 1, MPI_HYPRE_BIG_INT, num_procs-1, comm);
93
94 hypre_IJVectorGlobalFirstRow(vec) = row0;
95 hypre_IJVectorGlobalNumRows(vec) = rowN - row0 + 1;
96
97#else
98
99 info = hypre_CTAlloc(HYPRE_BigInt,2);
100 recv_buf = hypre_CTAlloc(HYPRE_BigInt, 2*num_procs);
101 partitioning = hypre_CTAlloc(HYPRE_BigInt, num_procs+1);
102
103 info[0] = jlower;
104 info[1] = jupper;
105
106 MPI_Allgather(info, 2, MPI_HYPRE_BIG_INT, recv_buf, 2, MPI_HYPRE_BIG_INT, comm);
107
108 partitioning[0] = recv_buf[0];
109 for (i=0; i < num_procs-1; i++)
110 {
111 i2 = i+i;
112 if (recv_buf[i2+1] != (recv_buf[i2+2]-1))
113 {
114 printf("Inconsistent partitioning -- HYPRE_IJVectorCreate\n");
115 hypre_error(HYPRE_ERROR_GENERIC);
116 return hypre_error_flag;
117 }
118 else
119 partitioning[i+1] = recv_buf[i2+2];
120 }
121 i2 = (num_procs-1)*2;
122 partitioning[num_procs] = recv_buf[i2+1]+1;
123
124 hypre_TFree(info);
125 hypre_TFree(recv_buf);
126
127
128 hypre_IJVectorGlobalFirstRow(vec) = partitioning[0];
129 hypre_IJVectorGlobalNumRows(vec)= partitioning[num_procs]-partitioning[0];
130
131
132
133#endif
134
135
136 hypre_IJVectorComm(vec) = comm;
137 hypre_IJVectorPartitioning(vec) = partitioning;
138 hypre_IJVectorObjectType(vec) = HYPRE_UNITIALIZED;
139 hypre_IJVectorObject(vec) = NULL;
140 hypre_IJVectorTranslator(vec) = NULL;
141
142 *vector = (HYPRE_IJVector) vec;
143
144 return hypre_error_flag;
145}
146
147/*--------------------------------------------------------------------------
148 * HYPRE_IJVectorDestroy
149 *--------------------------------------------------------------------------*/
150
151int
152HYPRE_IJVectorDestroy( HYPRE_IJVector vector )
153{
154 hypre_IJVector *vec = (hypre_IJVector *) vector;
155
156 if (!vec)
157 {
158 printf("Vector variable is NULL -- HYPRE_IJVectorDestroy\n");
159 hypre_error_in_arg(1);
160 return hypre_error_flag;
161 }
162
163 if (hypre_IJVectorPartitioning(vec))
164 hypre_TFree(hypre_IJVectorPartitioning(vec));
165
166 /* if ( hypre_IJVectorObjectType(vec) == HYPRE_PETSC )
167
168 ierr = hypre_IJVectorDestroyPETSc(vec) ;
169
170 else if ( hypre_IJVectorObjectType(vec) == HYPRE_ISIS )
171
172 ierr = hypre_IJVectorDestroyISIS(vec) ;
173
174 else */
175
176 if ( hypre_IJVectorObjectType(vec) == HYPRE_PARCSR )
177 {
178 hypre_IJVectorDestroyPar(vec) ;
179 if (hypre_IJVectorTranslator(vec))
180 {
181 hypre_AuxParVectorDestroy((hypre_AuxParVector *)
182 (hypre_IJVectorTranslator(vec)));
183 }
184 }
185 else if ( hypre_IJVectorObjectType(vec) != -1 )
186 {
187 printf("Unrecognized object type -- HYPRE_IJVectorDestroy\n");
188 hypre_error_in_arg(1);
189 return hypre_error_flag;
190 }
191
192 hypre_TFree(vec);
193
194 return hypre_error_flag;
195}
196
197/*--------------------------------------------------------------------------
198 * HYPRE_IJVectorInitialize
199 *--------------------------------------------------------------------------*/
200
201int
202HYPRE_IJVectorInitialize( HYPRE_IJVector vector )
203{
204 hypre_IJVector *vec = (hypre_IJVector *) vector;
205
206 if (!vec)
207 {
208 printf("Vector variable is NULL -- HYPRE_IJVectorInitialize\n");
209 hypre_error_in_arg(1);
210 return hypre_error_flag;
211 }
212
213 /* if ( hypre_IJVectorObjectType(vec) == HYPRE_PETSC )
214
215 return( hypre_IJVectorInitializePETSc(vec) );
216
217 else if ( hypre_IJVectorObjectType(vec) == HYPRE_ISIS )
218
219 return( hypre_IJVectorInitializeISIS(vec) );
220
221 else */
222
223 if ( hypre_IJVectorObjectType(vec) == HYPRE_PARCSR )
224 {
225 if (!hypre_IJVectorObject(vec))
226 hypre_IJVectorCreatePar(vec, hypre_IJVectorPartitioning(vec));
227
228 hypre_IJVectorInitializePar(vec);
229
230 }
231 else
232 {
233 printf("Unrecognized object type -- HYPRE_IJVectorInitialize\n");
234 hypre_error_in_arg(1);
235 }
236
237 return hypre_error_flag;
238}
239
240/*--------------------------------------------------------------------------
241 * HYPRE_IJVectorSetValues
242 *--------------------------------------------------------------------------*/
243
244int
245HYPRE_IJVectorSetValues( HYPRE_IJVector vector,
246 int nvalues,
247 const HYPRE_BigInt *indices,
248 const double *values )
249{
250 hypre_IJVector *vec = (hypre_IJVector *) vector;
251
252 if (nvalues == 0) return hypre_error_flag;
253
254 if (!vec)
255 {
256 printf("Vector is NULL -- HYPRE_IJVectorSetValues\n");
257 hypre_error_in_arg(1);
258 return hypre_error_flag;
259 }
260
261 if (nvalues < 0)
262 {
263 hypre_error_in_arg(2);
264 return hypre_error_flag;
265 }
266
267 if (!values)
268 {
269 hypre_error_in_arg(4);
270 return hypre_error_flag;
271 }
272
273 /* if ( hypre_IJVectorObjectType(vec) == HYPRE_PETSC )
274
275 return( hypre_IJVectorSetValuesPETSc(vec, nvalues, indices, values) );
276
277 else if ( hypre_IJVectorObjectType(vec) == HYPRE_ISIS )
278
279 return( hypre_IJVectorSetValuesISIS(vec, nvalues, indices, values) );
280
281 else */
282
283 if ( hypre_IJVectorObjectType(vec) == HYPRE_PARCSR )
284
285 return( hypre_IJVectorSetValuesPar(vec, nvalues, indices, values) );
286
287 else
288 {
289 printf("Unrecognized object type -- HYPRE_IJVectorSetValues\n");
290 hypre_error_in_arg(1);
291 }
292
293 return hypre_error_flag;
294}
295
296/*--------------------------------------------------------------------------
297 * HYPRE_IJVectorAddToValues
298 *--------------------------------------------------------------------------*/
299
300int
301HYPRE_IJVectorAddToValues( HYPRE_IJVector vector,
302 int nvalues,
303 const HYPRE_BigInt *indices,
304 const double *values )
305{
306 hypre_IJVector *vec = (hypre_IJVector *) vector;
307
308 if (nvalues == 0) return hypre_error_flag;
309
310 if (!vec)
311 {
312 printf("Variable vec is NULL -- HYPRE_IJVectorAddToValues\n");
313 hypre_error_in_arg(1);
314 return hypre_error_flag;
315 }
316
317 if (nvalues < 0)
318 {
319 hypre_error_in_arg(2);
320 return hypre_error_flag;
321 }
322
323 if (!values)
324 {
325 hypre_error_in_arg(4);
326 return hypre_error_flag;
327 }
328
329 /* if ( hypre_IJVectorObjectType(vec) == HYPRE_PETSC )
330
331 return( hypre_IJVectorAddToValuesPETSc(vec, nvalues, indices, values) );
332
333 else if ( hypre_IJVectorObjectType(vec) == HYPRE_ISIS )
334
335 return( hypre_IJVectorAddToValuesISIS(vec, nvalues, indices, values) );
336
337 else */ if ( hypre_IJVectorObjectType(vec) == HYPRE_PARCSR )
338
339 return( hypre_IJVectorAddToValuesPar(vec, nvalues, indices, values) );
340
341 else
342 {
343 printf("Unrecognized object type -- HYPRE_IJVectorAddToValues\n");
344 hypre_error_in_arg(1);
345 }
346
347 return hypre_error_flag;
348}
349
350/*--------------------------------------------------------------------------
351 * HYPRE_IJVectorAssemble
352 *--------------------------------------------------------------------------*/
353
354int
355HYPRE_IJVectorAssemble( HYPRE_IJVector vector )
356{
357 hypre_IJVector *vec = (hypre_IJVector *) vector;
358
359 if (!vec)
360 {
361 printf("Variable vec is NULL -- HYPRE_IJVectorAssemble\n");
362 hypre_error_in_arg(1);
363 return hypre_error_flag;
364 }
365
366 /* if ( hypre_IJVectorObjectType(vec) == HYPRE_PETSC )
367
368 return( hypre_IJVectorAssemblePETSc(vec) );
369
370 else if ( hypre_IJVectorObjectType(vec) == HYPRE_ISIS )
371
372 return( hypre_IJVectorAssembleISIS(vec) );
373
374 else */ if ( hypre_IJVectorObjectType(vec) == HYPRE_PARCSR )
375
376 return( hypre_IJVectorAssemblePar(vec) );
377
378 else
379 {
380 printf("Unrecognized object type -- HYPRE_IJVectorAssemble\n");
381 hypre_error_in_arg(1);
382 }
383
384 return hypre_error_flag;
385}
386
387/*--------------------------------------------------------------------------
388 * HYPRE_IJVectorGetValues
389 *--------------------------------------------------------------------------*/
390
391int
392HYPRE_IJVectorGetValues( HYPRE_IJVector vector,
393 int nvalues,
394 const HYPRE_BigInt *indices,
395 double *values )
396{
397 hypre_IJVector *vec = (hypre_IJVector *) vector;
398
399 if (nvalues == 0) return hypre_error_flag;
400
401 if (!vec)
402 {
403 printf("Variable vec is NULL -- HYPRE_IJVectorGetValues\n");
404 hypre_error_in_arg(1);
405 return hypre_error_flag;
406 }
407
408 if (nvalues < 0)
409 {
410 hypre_error_in_arg(2);
411 return hypre_error_flag;
412 }
413
414 if (!indices)
415 {
416 hypre_error_in_arg(3);
417 return hypre_error_flag;
418 }
419
420 if (!values)
421 {
422 hypre_error_in_arg(4);
423 return hypre_error_flag;
424 }
425
426 /* if ( hypre_IJVectorObjectType(vec) == HYPRE_PETSC )
427
428 return( hypre_GetIJVectorPETScLocalComponents(vec, nvalues, indices, values) );
429
430 else if ( hypre_IJVectorObjectType(vec) == HYPRE_ISIS )
431
432 return( hypre_IJVectorGetValuesISIS(vec, nvalues, indices, values) );
433
434 else */ if ( hypre_IJVectorObjectType(vec) == HYPRE_PARCSR )
435
436 return( hypre_IJVectorGetValuesPar(vec, nvalues, indices, values) );
437
438 else
439 {
440 printf("Unrecognized object type -- HYPRE_IJVectorGetValues\n");
441 hypre_error_in_arg(1);
442 }
443
444 return hypre_error_flag;
445}
446
447/*--------------------------------------------------------------------------
448 * HYPRE_IJVectorSetMaxOffProcElmts
449 *--------------------------------------------------------------------------*/
450
451int
452HYPRE_IJVectorSetMaxOffProcElmts( HYPRE_IJVector vector,
453 int max_off_proc_elmts)
454{
455 hypre_IJVector *vec = (hypre_IJVector *) vector;
456
457 if (!vec)
458 {
459 printf("Variable vec is NULL -- HYPRE_IJVectorSetObjectType\n");
460 hypre_error_in_arg(1);
461 return hypre_error_flag;
462 }
463
464 /* if ( hypre_IJVectorObjectType(vec) == HYPRE_PETSC )
465
466 return( hypre_IJVectorSetMaxOffProcElmtsPETSc(vec,
467 max_off_proc_elmts));
468
469 else if ( hypre_IJVectorObjectType(vec) == HYPRE_ISIS )
470 return( hypre_IJVectorSetMaxOffProcElmtsISIS(vec,
471 max_off_proc_elmts));
472
473 else */ if ( hypre_IJVectorObjectType(vec) == HYPRE_PARCSR )
474 return( hypre_IJVectorSetMaxOffProcElmtsPar(vec,
475 max_off_proc_elmts));
476
477 else
478 {
479 printf("Unrecognized object type -- HYPRE_IJVectorGetValues\n");
480 hypre_error_in_arg(1);
481 }
482
483 return hypre_error_flag;
484}
485
486/*--------------------------------------------------------------------------
487 * HYPRE_IJVectorSetObjectType
488 *--------------------------------------------------------------------------*/
489
490int
491HYPRE_IJVectorSetObjectType( HYPRE_IJVector vector, int type )
492{
493 hypre_IJVector *vec = (hypre_IJVector *) vector;
494
495 if (!vec)
496 {
497 printf("Variable vec is NULL -- HYPRE_IJVectorSetObjectType\n");
498 hypre_error_in_arg(1);
499 return hypre_error_flag;
500 }
501
502 hypre_IJVectorObjectType(vec) = type;
503
504 return hypre_error_flag;
505}
506
507/*--------------------------------------------------------------------------
508 * HYPRE_IJVectorGetObjectType
509 *--------------------------------------------------------------------------*/
510
511int
512HYPRE_IJVectorGetObjectType( HYPRE_IJVector vector, int *type )
513{
514 hypre_IJVector *vec = (hypre_IJVector *) vector;
515
516 if (!vec)
517 {
518 printf("Variable vec is NULL -- HYPRE_IJVectorGetObjectType\n");
519 hypre_error_in_arg(1);
520 return hypre_error_flag;
521 }
522
523 *type = hypre_IJVectorObjectType(vec);
524
525 return hypre_error_flag;
526}
527
528/*--------------------------------------------------------------------------
529 * HYPRE_IJVectorGetLocalRange
530 *--------------------------------------------------------------------------*/
531
532int
533HYPRE_IJVectorGetLocalRange( HYPRE_IJVector vector, HYPRE_BigInt *jlower, HYPRE_BigInt *jupper )
534{
535 hypre_IJVector *vec = (hypre_IJVector *) vector;
536 MPI_Comm comm;
537 HYPRE_BigInt *partitioning;
538 int my_id;
539
540 if (!vec)
541 {
542 printf("Variable vec is NULL -- HYPRE_IJVectorGetObjectType\n");
543 hypre_error_in_arg(1);
544 return hypre_error_flag;
545 }
546
547 comm = hypre_IJVectorComm(vec);
548 partitioning = hypre_IJVectorPartitioning(vec);
549 MPI_Comm_rank(comm, &my_id);
550
551#ifdef HYPRE_NO_GLOBAL_PARTITION
552 *jlower = partitioning[0];
553 *jupper = partitioning[1]-1;
554#else
555 *jlower = partitioning[my_id];
556 *jupper = partitioning[my_id+1]-1;
557#endif
558 return hypre_error_flag;
559}
560
561/*--------------------------------------------------------------------------
562 * HYPRE_IJVectorGetObject
563 *--------------------------------------------------------------------------*/
564
565int
566HYPRE_IJVectorGetObject( HYPRE_IJVector vector, void **object )
567{
568 hypre_IJVector *vec = (hypre_IJVector *) vector;
569
570 if (!vec)
571 {
572 printf("Variable vec is NULL -- HYPRE_IJVectorGetObject\n");
573 hypre_error_in_arg(1);
574 return hypre_error_flag;
575 }
576
577 *object = hypre_IJVectorObject(vec);
578
579 return hypre_error_flag;
580}
581
582/*--------------------------------------------------------------------------
583 * HYPRE_IJVectorRead
584 *--------------------------------------------------------------------------*/
585
586int
587HYPRE_IJVectorRead( const char *filename,
588 MPI_Comm comm,
589 int type,
590 HYPRE_IJVector *vector_ptr )
591{
592 HYPRE_IJVector vector;
593 HYPRE_BigInt jlower, jupper, j;
594 double value;
595 int myid;
596 char new_filename[255];
597 FILE *file;
598
599 MPI_Comm_rank(comm, &myid);
600
601 sprintf(new_filename,"%s.%05d", filename, myid);
602
603 if ((file = fopen(new_filename, "r")) == NULL)
604 {
605 printf("Error: can't open input file %s\n", new_filename);
606 hypre_error_in_arg(1);
607 return hypre_error_flag;
608 }
609
610#ifdef HYPRE_LONG_LONG
611 fscanf(file, "%lld %lld", &jlower, &jupper);
612#else
613 fscanf(file, "%d %d", &jlower, &jupper);
614#endif
615 HYPRE_IJVectorCreate(comm, jlower, jupper, &vector);
616
617 HYPRE_IJVectorSetObjectType(vector, type);
618 HYPRE_IJVectorInitialize(vector);
619
620#ifdef HYPRE_LONG_LONG
621 while ( fscanf(file, "%lld %le", &j, &value) != EOF )
622#else
623 while ( fscanf(file, "%d %le", &j, &value) != EOF )
624#endif
625 {
626 HYPRE_IJVectorSetValues(vector, 1, &j, &value);
627 }
628
629 HYPRE_IJVectorAssemble(vector);
630
631 fclose(file);
632
633 *vector_ptr = vector;
634
635 return hypre_error_flag;
636}
637
638/*--------------------------------------------------------------------------
639 * HYPRE_IJVectorPrint
640 *--------------------------------------------------------------------------*/
641
642int
643HYPRE_IJVectorPrint( HYPRE_IJVector vector,
644 const char *filename )
645{
646 MPI_Comm comm = hypre_IJVectorComm(vector);
647 HYPRE_BigInt *partitioning;
648 HYPRE_BigInt jlower, jupper, j;
649 double value;
650 int myid;
651 char new_filename[255];
652 FILE *file;
653
654 if (!vector)
655 {
656 printf("Variable vec is NULL -- HYPRE_IJVectorPrint\n");
657 hypre_error_in_arg(1);
658 return hypre_error_flag;
659 }
660
661 MPI_Comm_rank(comm, &myid);
662
663 sprintf(new_filename,"%s.%05d", filename, myid);
664
665 if ((file = fopen(new_filename, "w")) == NULL)
666 {
667 printf("Error: can't open output file %s\n", new_filename);
668 hypre_error_in_arg(2);
669 return hypre_error_flag;
670 }
671
672 partitioning = hypre_IJVectorPartitioning(vector);
673#ifdef HYPRE_NO_GLOBAL_PARTITION
674 jlower = partitioning[0];
675 jupper = partitioning[1] - 1;
676#else
677 jlower = partitioning[myid];
678 jupper = partitioning[myid+1] - 1;
679#endif
680#ifdef HYPRE_LONG_LONG
681 fprintf(file, "%lld %lld\n", jlower, jupper);
682#else
683 fprintf(file, "%d %d\n", jlower, jupper);
684#endif
685
686 for (j = jlower; j <= jupper; j++)
687 {
688 HYPRE_IJVectorGetValues(vector, 1, &j, &value);
689
690#ifdef HYPRE_LONG_LONG
691 fprintf(file, "%lld %.14e\n", j, value);
692#else
693 fprintf(file, "%d %.14e\n", j, value);
694#endif
695 }
696
697 fclose(file);
698
699 return hypre_error_flag;
700}
Note: See TracBrowser for help on using the repository browser.