286
290
SparsityPattern ();
289
* Constructor for a square sparsity
290
* pattern using an Epetra_Map and
291
* the number of nonzero entries in
292
* the rows of the sparsity
293
* pattern. Note that this number
294
* does not need to be exact, and it
295
* is even allowed that the actual
296
* sparsity structure has more
297
* nonzero entries than specified in
298
* the constructor. However it is
299
* still advantageous to provide good
300
* estimates here since this will
301
* considerably increase the
302
* performance when creating the
305
SparsityPattern (const Epetra_Map &InputMap,
306
const unsigned int n_entries_per_row = 0);
309
* Same as before, but now use the
310
* exact number of nonzeros in each m
311
* row. Since we know the number of
312
* elements in the sparsity pattern
313
* exactly in this case, we can
314
* already allocate the right amount
315
* of memory, which makes the
316
* creation process by the respective
317
* SparsityPattern::reinit call
318
* considerably faster. However, this
319
* is a rather unusual situation,
320
* since knowing the number of
321
* entries in each row is usually
322
* connected to knowing the indices
323
* of nonzero entries, which the
324
* sparsity pattern is designed to
327
SparsityPattern (const Epetra_Map &InputMap,
328
const std::vector<unsigned int> &n_entries_per_row);
331
* This constructor is similar to the
332
* one above, but it now takes two
333
* different Epetra maps for rows and
334
* columns. This interface is meant
335
* to be used for generating
336
* rectangular sparsity pattern,
337
* where one map describes the
338
* parallel partitioning of the dofs
339
* associated with the sparsity
340
* pattern rows and the other one of
341
* the sparsity pattern columns. Note
342
* that there is no real parallelism
343
* along the columns – the
344
* processor that owns a certain row
345
* always owns all the column
346
* elements, no matter how far they
347
* might be spread out. The second
348
* Epetra_Map is only used to specify
349
* the number of columns and for
350
* internal arragements when doing
351
* matrix-vector products with
352
* vectors based on that column map.
354
* The number of columns entries
355
* per row is specified as the
356
* maximum number of entries
359
SparsityPattern (const Epetra_Map &InputRowMap,
360
const Epetra_Map &InputColMap,
361
const unsigned int n_entries_per_row = 0);
364
* This constructor is similar to the
365
* one above, but it now takes two
366
* different Epetra maps for rows and
367
* columns. This interface is meant
368
* to be used for generating
369
* rectangular matrices, where one
370
* map specifies the parallel
371
* distribution of rows and the
372
* second one specifies the
373
* distribution of degrees of freedom
374
* associated with matrix
375
* columns. This second map is
376
* however not used for the
377
* distribution of the columns
378
* themselves – rather, all
379
* column elements of a row are
380
* stored on the same processor. The
381
* vector <tt>n_entries_per_row</tt>
382
* specifies the number of entries in
383
* each row of the newly generated
386
SparsityPattern (const Epetra_Map &InputRowMap,
387
const Epetra_Map &InputColMap,
388
const std::vector<unsigned int> &n_entries_per_row);
391
* Generate a sparsity pattern that
392
* is completely stored locally,
393
* having $m$ rows and $n$ columns. The
394
* resulting matrix will be
395
* completely stored locally.
397
* The number of columns entries per
398
* row is specified as the maximum
399
* number of entries argument. As
400
* above, this does not need to be an
401
* accurate number since the entries
402
* are allocated dynamically in a
403
* similar manner as for the deal.II
404
* CompressedSparsityPattern classes,
405
* but a good estimate will reduce
406
* the setup time of the sparsity
293
* Generate a sparsity pattern that is
294
* completely stored locally, having
295
* $m$ rows and $n$ columns. The
296
* resulting matrix will be completely
297
* stored locally, too.
299
* It is possible to specify the
300
* number of columns entries per row
301
* using the optional @p
303
* argument. However, this value does
304
* not need to be accurate or even
305
* given at all, since one does
306
* usually not have this kind of
307
* information before building the
308
* sparsity pattern (the usual case
310
* DoFTools::make_sparsity_pattern()
311
* is called). The entries are
312
* allocated dynamically in a similar
313
* manner as for the deal.II
314
* CompressedSparsityPattern
315
* classes. However, a good estimate
316
* will reduce the setup time of the
409
319
SparsityPattern (const unsigned int m,
410
320
const unsigned int n,
411
321
const unsigned int n_entries_per_row = 0);
414
* Generate a sparsity pattern that
415
* is completely stored locally,
416
* having $m$ rows and $n$ columns. The
417
* resulting matrix will be
418
* completely stored locally.
324
* Generate a sparsity pattern that is
325
* completely stored locally, having
326
* $m$ rows and $n$ columns. The
327
* resulting matrix will be completely
328
* stored locally, too.
421
331
* <tt>n_entries_per_row</tt>
422
332
* specifies the number of entries in
333
* each row (an information usually
334
* not available, though).
425
336
SparsityPattern (const unsigned int m,
426
337
const unsigned int n,
441
352
virtual ~SparsityPattern ();
444
* Reinitialization function for
445
* generating a square sparsity
446
* pattern using an Epetra_Map and
447
* the number of nonzero entries in
448
* the rows of the sparsity
449
* pattern. Note that this number
450
* does not need to be exact, and it
451
* is even allowed that the actual
452
* sparsity structure has more
453
* nonzero entries than specified in
454
* the constructor. However it is
455
* still advantageous to provide good
456
* estimates here since this will
457
* considerably increase the
458
* performance when creating the
461
* This function does not create any
462
* entries by itself, but provides
463
* the correct data structures that
464
* can be used by the respective
468
reinit (const Epetra_Map &InputMap,
469
const unsigned int n_entries_per_row = 0);
472
* Same as before, but now use the
473
* exact number of nonzeros in each m
474
* row. Since we know the number of
475
* elements in the sparsity pattern
476
* exactly in this case, we can
477
* already allocate the right amount
478
* of memory, which makes process of
479
* adding entries to the sparsity
480
* pattern considerably
481
* faster. However, this is a rather
482
* unusual situation, since knowing
483
* the number of entries in each row
484
* is usually connected to knowing
485
* the indices of nonzero entries,
486
* which the sparsity pattern is
487
* designed to describe.
490
reinit (const Epetra_Map &InputMap,
491
const std::vector<unsigned int> &n_entries_per_row);
494
* This reinit function is similar to
495
* the one above, but it now takes
496
* two different Epetra maps for rows
497
* and columns. This interface is
498
* meant to be used for generating
499
* rectangular sparsity pattern,
500
* where one map describes the
501
* parallel partitioning of the dofs
502
* associated with the sparsity
503
* pattern rows and the other one of
504
* the sparsity pattern columns. Note
505
* that there is no real parallelism
506
* along the columns – the
507
* processor that owns a certain row
508
* always owns all the column
509
* elements, no matter how far they
510
* might be spread out. The second
511
* Epetra_Map is only used to specify
512
* the number of columns and for
513
* internal arragements when doing
514
* matrix-vector products with
515
* vectors based on that column map.
517
* The number of columns entries per
518
* row is specified by the argument
519
* <tt>n_entries_per_row</tt>.
522
reinit (const Epetra_Map &InputRowMap,
523
const Epetra_Map &InputColMap,
524
const unsigned int n_entries_per_row = 0);
527
* This reinit function is similar to
528
* the one above, but it now takes
529
* two different Epetra maps for rows
530
* and columns. This interface is
531
* meant to be used for generating
532
* rectangular matrices, where one
533
* map specifies the parallel
534
* distribution of rows and the
535
* second one specifies the
536
* distribution of degrees of freedom
537
* associated with matrix
538
* columns. This second map is
539
* however not used for the
540
* distribution of the columns
541
* themselves – rather, all
542
* column elements of a row are
543
* stored on the same processor. The
544
* vector <tt>n_entries_per_row</tt>
545
* specifies the number of entries in
546
* each row of the newly generated
550
reinit (const Epetra_Map &InputRowMap,
551
const Epetra_Map &InputColMap,
552
const std::vector<unsigned int> &n_entries_per_row);
555
355
* Initialize a sparsity pattern that
556
356
* is completely stored locally,
557
* having $m$ rows and $n$ columns. The
558
* resulting matrix will be
559
* completely stored locally.
357
* having $m$ rows and $n$
358
* columns. The resulting matrix will
359
* be completely stored locally.
561
361
* The number of columns entries per
562
362
* row is specified as the maximum
563
* number of entries argument. As
564
* above, this does not need to be an
565
* accurate number since the entries
566
* are allocated dynamically in a
567
* similar manner as for the deal.II
363
* number of entries argument. This
364
* does not need to be an accurate
365
* number since the entries are
366
* allocated dynamically in a similar
367
* manner as for the deal.II
568
368
* CompressedSparsityPattern classes,
569
369
* but a good estimate will reduce
570
370
* the setup time of the sparsity
574
374
reinit (const unsigned int m,
575
375
const unsigned int n,
576
376
const unsigned int n_entries_per_row = 0);
669
456
void compress ();
459
* @name Constructors and initialization using an Epetra_Map description
464
* Constructor for a square sparsity
465
* pattern using an Epetra_map for
466
* the description of the %parallel
467
* partitioning. Moreover, the number
468
* of nonzero entries in the rows of
469
* the sparsity pattern can be
470
* specified. Note that this number
471
* does not need to be exact, and it
472
* is allowed that the actual
473
* sparsity structure has more
474
* nonzero entries than specified in
475
* the constructor (the usual case
477
* DoFTools::make_sparsity_pattern()
478
* is called). However it is still
479
* advantageous to provide good
480
* estimates here since a good value
481
* will avoid repeated allocation of
482
* memory, which considerably
483
* increases the performance when
484
* creating the sparsity pattern.
486
SparsityPattern (const Epetra_Map ¶llel_partitioning,
487
const unsigned int n_entries_per_row = 0);
490
* Same as before, but now use the
491
* exact number of nonzeros in each m
492
* row. Since we know the number of
493
* elements in the sparsity pattern
494
* exactly in this case, we can
495
* already allocate the right amount
496
* of memory, which makes the
497
* creation process by the respective
498
* SparsityPattern::reinit call
499
* considerably faster. However, this
500
* is a rather unusual situation,
501
* since knowing the number of
502
* entries in each row is usually
503
* connected to knowing the indices
504
* of nonzero entries, which the
505
* sparsity pattern is designed to
508
SparsityPattern (const Epetra_Map ¶llel_partitioning,
509
const std::vector<unsigned int> &n_entries_per_row);
512
* This constructor is similar to the
513
* one above, but it now takes two
514
* different Epetra maps for rows and
515
* columns. This interface is meant to
516
* be used for generating rectangular
517
* sparsity pattern, where one map
518
* describes the %parallel partitioning
519
* of the dofs associated with the
520
* sparsity pattern rows and the other
521
* one of the sparsity pattern
522
* columns. Note that there is no real
523
* parallelism along the columns
524
* – the processor that owns a
525
* certain row always owns all the
526
* column elements, no matter how far
527
* they might be spread out. The second
528
* Epetra_Map is only used to specify
529
* the number of columns and for
530
* specifying the correct domain space
531
* when performing matrix-vector
532
* products with vectors based on the
535
* The number of columns entries per
536
* row is specified as the maximum
537
* number of entries argument.
539
SparsityPattern (const Epetra_Map &row_parallel_partitioning,
540
const Epetra_Map &col_parallel_partitioning,
541
const unsigned int n_entries_per_row = 0);
544
* This constructor is similar to the
545
* one above, but it now takes two
546
* different Epetra maps for rows and
547
* columns. This interface is meant to
548
* be used for generating rectangular
549
* matrices, where one map specifies
550
* the %parallel distribution of rows
551
* and the second one specifies the
552
* distribution of degrees of freedom
553
* associated with matrix columns. This
554
* second map is however not used for
555
* the distribution of the columns
556
* themselves – rather, all
557
* column elements of a row are stored
558
* on the same processor. The vector
559
* <tt>n_entries_per_row</tt> specifies
560
* the number of entries in each row of
561
* the newly generated matrix.
563
SparsityPattern (const Epetra_Map &row_parallel_partitioning,
564
const Epetra_Map &col_parallel_partitioning,
565
const std::vector<unsigned int> &n_entries_per_row);
568
* Reinitialization function for
569
* generating a square sparsity pattern
570
* using an Epetra_Map for the
571
* description of the %parallel
572
* partitioning and the number of
573
* nonzero entries in the rows of the
574
* sparsity pattern. Note that this
575
* number does not need to be exact,
576
* and it is even allowed that the
577
* actual sparsity structure has more
578
* nonzero entries than specified in
579
* the constructor. However it is still
580
* advantageous to provide good
581
* estimates here since this will
582
* considerably increase the
583
* performance when creating the
586
* This function does not create any
587
* entries by itself, but provides
588
* the correct data structures that
589
* can be used by the respective
593
reinit (const Epetra_Map ¶llel_partitioning,
594
const unsigned int n_entries_per_row = 0);
597
* Same as before, but now use the
598
* exact number of nonzeros in each m
599
* row. Since we know the number of
600
* elements in the sparsity pattern
601
* exactly in this case, we can
602
* already allocate the right amount
603
* of memory, which makes process of
604
* adding entries to the sparsity
605
* pattern considerably
606
* faster. However, this is a rather
607
* unusual situation, since knowing
608
* the number of entries in each row
609
* is usually connected to knowing
610
* the indices of nonzero entries,
611
* which the sparsity pattern is
612
* designed to describe.
615
reinit (const Epetra_Map ¶llel_partitioning,
616
const std::vector<unsigned int> &n_entries_per_row);
619
* This reinit function is similar to
620
* the one above, but it now takes
621
* two different Epetra maps for rows
622
* and columns. This interface is
623
* meant to be used for generating
624
* rectangular sparsity pattern,
625
* where one map describes the
626
* %parallel partitioning of the dofs
627
* associated with the sparsity
628
* pattern rows and the other one of
629
* the sparsity pattern columns. Note
630
* that there is no real parallelism
631
* along the columns – the
632
* processor that owns a certain row
633
* always owns all the column
634
* elements, no matter how far they
635
* might be spread out. The second
636
* Epetra_Map is only used to specify
637
* the number of columns and for
638
* internal arragements when doing
639
* matrix-vector products with
640
* vectors based on that column map.
642
* The number of columns entries per
643
* row is specified by the argument
644
* <tt>n_entries_per_row</tt>.
647
reinit (const Epetra_Map &row_parallel_partitioning,
648
const Epetra_Map &col_parallel_partitioning,
649
const unsigned int n_entries_per_row = 0);
652
* This reinit function is similar to
653
* the one above, but it now takes
654
* two different Epetra maps for rows
655
* and columns. This interface is
656
* meant to be used for generating
657
* rectangular matrices, where one
658
* map specifies the %parallel
659
* distribution of rows and the
660
* second one specifies the
661
* distribution of degrees of freedom
662
* associated with matrix
663
* columns. This second map is
664
* however not used for the
665
* distribution of the columns
666
* themselves – rather, all
667
* column elements of a row are
668
* stored on the same processor. The
669
* vector <tt>n_entries_per_row</tt>
670
* specifies the number of entries in
671
* each row of the newly generated
675
reinit (const Epetra_Map &row_parallel_partitioning,
676
const Epetra_Map &col_parallel_partitioning,
677
const std::vector<unsigned int> &n_entries_per_row);
680
* Reinit function. Takes one of the
681
* deal.II sparsity patterns and a
682
* %parallel partitioning of the rows
683
* and columns for initializing the
684
* current Trilinos sparsity
685
* pattern. The optional argument @p
686
* exchange_data can be used for
687
* reinitialization with a sparsity
688
* pattern that is not fully
689
* constructed. This feature is only
690
* implemented for input sparsity
692
* CompressedSimpleSparsityPattern.
694
template<typename SparsityType>
696
reinit (const Epetra_Map &row_parallel_partitioning,
697
const Epetra_Map &col_parallel_partitioning,
698
const SparsityType &nontrilinos_sparsity_pattern,
699
const bool exchange_data = false);
702
* Reinit function. Takes one of the
703
* deal.II sparsity patterns and a
704
* %parallel partitioning of the rows
705
* and columns for initializing the
706
* current Trilinos sparsity
707
* pattern. The optional argument @p
708
* exchange_data can be used for
709
* reinitialization with a sparsity
710
* pattern that is not fully
711
* constructed. This feature is only
712
* implemented for input sparsity
714
* CompressedSimpleSparsityPattern.
716
template<typename SparsityType>
718
reinit (const Epetra_Map ¶llel_partitioning,
719
const SparsityType &nontrilinos_sparsity_pattern,
720
const bool exchange_data = false);
723
* @name Constructors and initialization using an IndexSet description
728
* Constructor for a square sparsity
729
* pattern using an IndexSet and an
730
* MPI communicator for the
731
* description of the %parallel
732
* partitioning. Moreover, the number
733
* of nonzero entries in the rows of
734
* the sparsity pattern can be
735
* specified. Note that this number
736
* does not need to be exact, and it
737
* is even allowed that the actual
738
* sparsity structure has more
739
* nonzero entries than specified in
740
* the constructor. However it is
741
* still advantageous to provide good
742
* estimates here since a good value
743
* will avoid repeated allocation of
744
* memory, which considerably
745
* increases the performance when
746
* creating the sparsity pattern.
748
SparsityPattern (const IndexSet ¶llel_partitioning,
749
const MPI_Comm &communicator = MPI_COMM_WORLD,
750
const unsigned int n_entries_per_row = 0);
753
* Same as before, but now use the
754
* exact number of nonzeros in each m
755
* row. Since we know the number of
756
* elements in the sparsity pattern
757
* exactly in this case, we can
758
* already allocate the right amount
759
* of memory, which makes the
760
* creation process by the respective
761
* SparsityPattern::reinit call
762
* considerably faster. However, this
763
* is a rather unusual situation,
764
* since knowing the number of
765
* entries in each row is usually
766
* connected to knowing the indices
767
* of nonzero entries, which the
768
* sparsity pattern is designed to
771
SparsityPattern (const IndexSet ¶llel_partitioning,
772
const MPI_Comm &communicator,
773
const std::vector<unsigned int> &n_entries_per_row);
776
* This constructor is similar to the
777
* one above, but it now takes two
778
* different index sets to describe the
779
* %parallel partitioning of rows and
780
* columns. This interface is meant to
781
* be used for generating rectangular
782
* sparsity pattern. Note that there is
783
* no real parallelism along the
784
* columns – the processor that
785
* owns a certain row always owns all
786
* the column elements, no matter how
787
* far they might be spread out. The
788
* second Epetra_Map is only used to
789
* specify the number of columns and
790
* for internal arragements when doing
791
* matrix-vector products with vectors
792
* based on that column map.
794
* The number of columns entries per
795
* row is specified as the maximum
796
* number of entries argument.
798
SparsityPattern (const IndexSet &row_parallel_partitioning,
799
const IndexSet &col_parallel_partitioning,
800
const MPI_Comm &communicator = MPI_COMM_WORLD,
801
const unsigned int n_entries_per_row = 0);
804
* This constructor is similar to the
805
* one above, but it now takes two
806
* different index sets for rows and
807
* columns. This interface is meant to
808
* be used for generating rectangular
809
* matrices, where one map specifies
810
* the %parallel distribution of rows
811
* and the second one specifies the
812
* distribution of degrees of freedom
813
* associated with matrix columns. This
814
* second map is however not used for
815
* the distribution of the columns
816
* themselves – rather, all
817
* column elements of a row are stored
818
* on the same processor. The vector
819
* <tt>n_entries_per_row</tt> specifies
820
* the number of entries in each row of
821
* the newly generated matrix.
823
SparsityPattern (const IndexSet &row_parallel_partitioning,
824
const IndexSet &col_parallel_partitioning,
825
const MPI_Comm &communicator,
826
const std::vector<unsigned int> &n_entries_per_row);
829
* Reinitialization function for
830
* generating a square sparsity
831
* pattern using an IndexSet and an
832
* MPI communicator for the
833
* description of the %parallel
834
* partitioning and the number of
835
* nonzero entries in the rows of the
836
* sparsity pattern. Note that this
837
* number does not need to be exact,
838
* and it is even allowed that the
839
* actual sparsity structure has more
840
* nonzero entries than specified in
841
* the constructor. However it is
842
* still advantageous to provide good
843
* estimates here since this will
844
* considerably increase the
845
* performance when creating the
848
* This function does not create any
849
* entries by itself, but provides
850
* the correct data structures that
851
* can be used by the respective
855
reinit (const IndexSet ¶llel_partitioning,
856
const MPI_Comm &communicator = MPI_COMM_WORLD,
857
const unsigned int n_entries_per_row = 0);
860
* Same as before, but now use the
861
* exact number of nonzeros in each m
862
* row. Since we know the number of
863
* elements in the sparsity pattern
864
* exactly in this case, we can
865
* already allocate the right amount
866
* of memory, which makes process of
867
* adding entries to the sparsity
868
* pattern considerably
869
* faster. However, this is a rather
870
* unusual situation, since knowing
871
* the number of entries in each row
872
* is usually connected to knowing
873
* the indices of nonzero entries,
874
* which the sparsity pattern is
875
* designed to describe.
878
reinit (const IndexSet ¶llel_partitioning,
879
const MPI_Comm &communicator,
880
const std::vector<unsigned int> &n_entries_per_row);
883
* This reinit function is similar to
884
* the one above, but it now takes
885
* two different index sets for rows
886
* and columns. This interface is
887
* meant to be used for generating
888
* rectangular sparsity pattern,
889
* where one index set describes the
890
* %parallel partitioning of the dofs
891
* associated with the sparsity
892
* pattern rows and the other one of
893
* the sparsity pattern columns. Note
894
* that there is no real parallelism
895
* along the columns – the
896
* processor that owns a certain row
897
* always owns all the column
898
* elements, no matter how far they
899
* might be spread out. The second
900
* IndexSet is only used to specify
901
* the number of columns and for
902
* internal arragements when doing
903
* matrix-vector products with
904
* vectors based on an EpetraMap
905
* based on that IndexSet.
907
* The number of columns entries per
908
* row is specified by the argument
909
* <tt>n_entries_per_row</tt>.
912
reinit (const IndexSet &row_parallel_partitioning,
913
const IndexSet &col_parallel_partitioning,
914
const MPI_Comm &communicator = MPI_COMM_WORLD,
915
const unsigned int n_entries_per_row = 0);
918
* Same as before, but now using a
919
* vector <tt>n_entries_per_row</tt>
920
* for specifying the number of
921
* entries in each row of the
925
reinit (const IndexSet &row_parallel_partitioning,
926
const IndexSet &col_parallel_partitioning,
927
const MPI_Comm &communicator,
928
const std::vector<unsigned int> &n_entries_per_row);
931
* Reinit function. Takes one of the
932
* deal.II sparsity patterns and the
933
* %parallel partitioning of the rows
934
* and columns specified by two index
935
* sets and a %parallel communicator
936
* for initializing the current
937
* Trilinos sparsity pattern. The
938
* optional argument @p exchange_data
939
* can be used for reinitialization
940
* with a sparsity pattern that is
941
* not fully constructed. This
942
* feature is only implemented for
943
* input sparsity patterns of type
944
* CompressedSimpleSparsityPattern.
946
template<typename SparsityType>
948
reinit (const IndexSet &row_parallel_partitioning,
949
const IndexSet &col_parallel_partitioning,
950
const SparsityType &nontrilinos_sparsity_pattern,
951
const MPI_Comm &communicator = MPI_COMM_WORLD,
952
const bool exchange_data = false);
955
* Reinit function. Takes one of the
956
* deal.II sparsity patterns and a
957
* %parallel partitioning of the rows
958
* and columns for initializing the
959
* current Trilinos sparsity
960
* pattern. The optional argument @p
961
* exchange_data can be used for
962
* reinitialization with a sparsity
963
* pattern that is not fully
964
* constructed. This feature is only
965
* implemented for input sparsity
967
* CompressedSimpleSparsityPattern.
969
template<typename SparsityType>
971
reinit (const IndexSet ¶llel_partitioning,
972
const SparsityType &nontrilinos_sparsity_pattern,
973
const MPI_Comm &communicator = MPI_COMM_WORLD,
974
const bool exchange_data = false);
672
977
* @name Information on the sparsity pattern
1690
SparsityPattern::trilinos_communicator () const
1692
return graph->RangeMap().Comm();
1698
SparsityPattern::SparsityPattern (const IndexSet ¶llel_partitioning,
1699
const MPI_Comm &communicator,
1700
const unsigned int n_entries_per_row)
1704
Epetra_Map map = parallel_partitioning.make_trilinos_map (communicator,
1706
reinit (map, map, n_entries_per_row);
1712
SparsityPattern::SparsityPattern (const IndexSet ¶llel_partitioning,
1713
const MPI_Comm &communicator,
1714
const std::vector<unsigned int> &n_entries_per_row)
1718
Epetra_Map map = parallel_partitioning.make_trilinos_map (communicator,
1720
reinit (map, map, n_entries_per_row);
1726
SparsityPattern::SparsityPattern (const IndexSet &row_parallel_partitioning,
1727
const IndexSet &col_parallel_partitioning,
1728
const MPI_Comm &communicator,
1729
const unsigned int n_entries_per_row)
1733
Epetra_Map row_map =
1734
row_parallel_partitioning.make_trilinos_map (communicator, false);
1735
Epetra_Map col_map =
1736
col_parallel_partitioning.make_trilinos_map (communicator, false);
1737
reinit (row_map, col_map, n_entries_per_row);
1744
SparsityPattern (const IndexSet &row_parallel_partitioning,
1745
const IndexSet &col_parallel_partitioning,
1746
const MPI_Comm &communicator,
1747
const std::vector<unsigned int> &n_entries_per_row)
1751
Epetra_Map row_map =
1752
row_parallel_partitioning.make_trilinos_map (communicator, false);
1753
Epetra_Map col_map =
1754
col_parallel_partitioning.make_trilinos_map (communicator, false);
1755
reinit (row_map, col_map, n_entries_per_row);
1762
SparsityPattern::reinit (const IndexSet ¶llel_partitioning,
1763
const MPI_Comm &communicator,
1764
const unsigned int n_entries_per_row)
1766
Epetra_Map map = parallel_partitioning.make_trilinos_map (communicator,
1768
reinit (map, map, n_entries_per_row);
1774
void SparsityPattern::reinit (const IndexSet ¶llel_partitioning,
1775
const MPI_Comm &communicator,
1776
const std::vector<unsigned int> &n_entries_per_row)
1778
Epetra_Map map = parallel_partitioning.make_trilinos_map (communicator,
1780
reinit (map, map, n_entries_per_row);
1786
void SparsityPattern::reinit (const IndexSet &row_parallel_partitioning,
1787
const IndexSet &col_parallel_partitioning,
1788
const MPI_Comm &communicator,
1789
const unsigned int n_entries_per_row)
1791
Epetra_Map row_map =
1792
row_parallel_partitioning.make_trilinos_map (communicator, false);
1793
Epetra_Map col_map =
1794
col_parallel_partitioning.make_trilinos_map (communicator, false);
1795
reinit (row_map, col_map, n_entries_per_row);
1801
SparsityPattern::reinit (const IndexSet &row_parallel_partitioning,
1802
const IndexSet &col_parallel_partitioning,
1803
const MPI_Comm &communicator,
1804
const std::vector<unsigned int> &n_entries_per_row)
1806
Epetra_Map row_map =
1807
row_parallel_partitioning.make_trilinos_map (communicator, false);
1808
Epetra_Map col_map =
1809
col_parallel_partitioning.make_trilinos_map (communicator, false);
1810
reinit (row_map, col_map, n_entries_per_row);
1815
template<typename SparsityType>
1818
SparsityPattern::reinit (const IndexSet &row_parallel_partitioning,
1819
const IndexSet &col_parallel_partitioning,
1820
const SparsityType &nontrilinos_sparsity_pattern,
1821
const MPI_Comm &communicator,
1822
const bool exchange_data)
1824
Epetra_Map row_map =
1825
row_parallel_partitioning.make_trilinos_map (communicator, false);
1826
Epetra_Map col_map =
1827
col_parallel_partitioning.make_trilinos_map (communicator, false);
1828
reinit (row_map, col_map, nontrilinos_sparsity_pattern, exchange_data);
1833
template<typename SparsityType>
1836
SparsityPattern::reinit (const IndexSet ¶llel_partitioning,
1837
const SparsityType &nontrilinos_sparsity_pattern,
1838
const MPI_Comm &communicator,
1839
const bool exchange_data)
1841
Epetra_Map map = parallel_partitioning.make_trilinos_map (communicator,
1843
reinit (map, map, nontrilinos_sparsity_pattern, exchange_data);
added
removed
lac/include/lac/trilinos_sparsity_pattern.h
