2 #ifndef __MATRIXMARKET_TPETRA_NEW_HPP
3 #define __MATRIXMARKET_TPETRA_NEW_HPP
24 template <
typename global_ordinal_type,
typename scalar_type>
26 Teuchos::RCP<Distribution<global_ordinal_type,scalar_type> >
28 std::string &distribution,
32 const Teuchos::ParameterList ¶ms,
33 const Teuchos::RCP<
const Teuchos::Comm<int> > &comm
40 int me = comm->getRank();
42 using basedist_t = Distribution<global_ordinal_type,scalar_type>;
45 bool randomize =
false;
47 const Teuchos::ParameterEntry *pe = params.getEntryPtr(
"randomize");
49 randomize = pe->getValue<
bool>(&randomize);
52 std::string partitionFile =
"";
54 const Teuchos::ParameterEntry *pe = params.getEntryPtr(
"partitionFile");
56 partitionFile = pe->getValue<std::string>(&partitionFile);
59 if (distribution ==
"2D") {
60 if (partitionFile !=
"") {
62 TEUCHOS_TEST_FOR_EXCEPTION(randomize, std::logic_error,
63 "Randomization not available for 2DVec distributions.");
64 Distribution2DVec<global_ordinal_type,scalar_type> *dist =
65 new Distribution2DVec<global_ordinal_type, scalar_type>(
66 nRow, comm, params, partitionFile);
67 retval =
dynamic_cast<basedist_t *
>(dist);
71 Distribution2DRandom<global_ordinal_type,scalar_type> *dist =
72 new Distribution2DRandom<global_ordinal_type,scalar_type>(
74 retval =
dynamic_cast<basedist_t *
>(dist);
79 Distribution2DLinear<global_ordinal_type,scalar_type> *dist =
80 new Distribution2DLinear<global_ordinal_type,scalar_type>(
82 retval =
dynamic_cast<basedist_t *
>(dist);
85 else if (distribution ==
"1D") {
86 if (partitionFile !=
"") {
88 Distribution1DVec<global_ordinal_type,scalar_type> *dist =
89 new Distribution1DVec<global_ordinal_type,scalar_type>(
90 nRow, comm, params, partitionFile);
91 retval =
dynamic_cast<basedist_t*
>(dist);
95 Distribution1DRandom<global_ordinal_type,scalar_type> *dist =
96 new Distribution1DRandom<global_ordinal_type,scalar_type>(
98 retval =
dynamic_cast<basedist_t *
>(dist);
102 Distribution1DLinear<global_ordinal_type,scalar_type> *dist =
103 new Distribution1DLinear<global_ordinal_type,scalar_type>(
105 retval =
dynamic_cast<basedist_t *
>(dist);
108 else if (distribution ==
"LowerTriangularBlock") {
109 if (randomize && me == 0) {
110 std::cout <<
"WARNING: Randomization not available for "
111 <<
"LowerTriangularBlock distributions." << std::endl;
114 DistributionLowerTriangularBlock<global_ordinal_type,scalar_type> *dist =
115 new DistributionLowerTriangularBlock<global_ordinal_type,scalar_type>(
117 retval =
dynamic_cast<basedist_t*
>(dist);
119 else if (distribution ==
"MMFile") {
121 if (randomize && me == 0) {
122 std::cout <<
"WARNING: Randomization not available for MMFile "
123 <<
"distributions." << std::endl;
125 DistributionMMFile<global_ordinal_type,scalar_type> *dist =
126 new DistributionMMFile<global_ordinal_type,scalar_type>(
128 retval =
dynamic_cast<basedist_t*
>(dist);
132 std::cout <<
"ERROR: Invalid distribution method " << distribution
136 return Teuchos::rcp<basedist_t>(retval);
142 const std::string &filename,
143 const Teuchos::RCP<
const Teuchos::Comm<int> > &comm,
144 const Teuchos::ParameterList ¶ms,
147 typename Distribution<global_ordinal_type,scalar_type>::LocalNZmap_t &localNZ,
148 Teuchos::RCP<Distribution<global_ordinal_type,scalar_type> > &dist
151 bool useTimers =
false;
153 const Teuchos::ParameterEntry *pe = params.getEntryPtr(
"useTimers");
155 useTimers = pe->getValue<
bool>(&useTimers);
158 Teuchos::RCP<Teuchos::TimeMonitor> timer = Teuchos::null;
160 timer = rcp(
new Teuchos::TimeMonitor(
161 *Teuchos::TimeMonitor::getNewTimer(
"RMM parameterSetup")));
163 int me = comm->getRank();
165 bool verbose =
false;
167 const Teuchos::ParameterEntry *pe = params.getEntryPtr(
"verbose");
169 verbose = pe->getValue<
bool>(&verbose);
172 size_t chunkSize = 500000;
174 const Teuchos::ParameterEntry *pe = params.getEntryPtr(
"chunkSize");
176 chunkSize = pe->getValue<
size_t>(&chunkSize);
179 bool symmetrize =
false;
181 const Teuchos::ParameterEntry *pe = params.getEntryPtr(
"symmetrize");
183 symmetrize = pe->getValue<
bool>(&symmetrize);
186 bool transpose =
false;
188 const Teuchos::ParameterEntry *pe = params.getEntryPtr(
"transpose");
190 transpose = pe->getValue<
bool>(&transpose);
193 std::string diagonal =
"";
197 const Teuchos::ParameterEntry *pe = params.getEntryPtr(
"diagonal");
199 diagonal = pe->getValue<std::string>(&diagonal);
201 bool ignoreDiagonal = (diagonal ==
"exclude");
202 bool requireDiagonal = (diagonal ==
"require");
204 std::string distribution =
"1D";
206 const Teuchos::ParameterEntry *pe = params.getEntryPtr(
"distribution");
208 distribution = pe->getValue<std::string>(&distribution);
212 timer = Teuchos::null;
213 timer = rcp(
new Teuchos::TimeMonitor(
214 *Teuchos::TimeMonitor::getNewTimer(
"RMM header")));
217 if (verbose && me == 0)
218 std::cout <<
"Reading matrix market file... " << filename << std::endl;
221 size_t dim[3] = {0,0,0};
226 fp = fopen(filename.c_str(),
"r");
229 std::cout <<
"Error: cannot open file " << filename << std::endl;
233 if (mm_read_banner(fp, &mmcode) != 0) {
234 std::cout <<
"Error: bad MatrixMarket banner " << std::endl;
238 if (!mm_is_valid(mmcode) ||
239 mm_is_dense(mmcode) || mm_is_array(mmcode) ||
240 mm_is_complex(mmcode) ||
241 mm_is_skew(mmcode) || mm_is_hermitian(mmcode)) {
242 std::cout <<
"Error: matrix type is not supported by this reader\n "
243 <<
"This reader supports sparse, coordinate, "
244 <<
"real, pattern, integer, symmetric, general"
249 if (mm_read_mtx_crd_size(fp, &dim[0], &dim[1], &dim[2]) != 0) {
250 std::cout <<
"Error: bad matrix dimensions " << std::endl;
251 dim[0] = dim[1] = dim[2] = 0;
261 Teuchos::broadcast<int, size_t>(*comm, 0, 3, dim);
262 if (dim[0] == 0 || dim[1] == 0) {
263 throw std::runtime_error(
"Error: bad matrix header information");
265 Teuchos::broadcast<int, char>(*comm, 0,
sizeof(MM_typecode), mmcode);
270 TEUCHOS_TEST_FOR_EXCEPTION(nRow != nCol, std::logic_error,
271 "This overload of readSparseFile requires nRow == nCol "
272 <<
"(nRow = " << nRow <<
", nCol = " << nCol <<
"); "
273 <<
"For now, use a different overload of readSparseFile until this "
274 <<
"overload is fixed to read rectangular matrices. "
275 <<
"See Trilinos github issues #7045 and #8472.");
278 bool patternInput = mm_is_pattern(mmcode);
279 bool symmetricInput = mm_is_symmetric(mmcode);
280 if (symmetricInput) symmetrize =
true;
282 if (verbose && me == 0)
283 std::cout <<
"Matrix market file... "
284 <<
"\n symmetrize = " << symmetrize
285 <<
"\n transpose = " << transpose
286 <<
"\n change diagonal = " << diagonal
287 <<
"\n distribution = " << distribution
291 timer = Teuchos::null;
292 timer = rcp(
new Teuchos::TimeMonitor(
293 *Teuchos::TimeMonitor::getNewTimer(
"RMM distribution")));
297 dist = buildDistribution<global_ordinal_type,scalar_type>(distribution,
301 timer = Teuchos::null;
302 timer = rcp(
new Teuchos::TimeMonitor(
303 *Teuchos::TimeMonitor::getNewTimer(
"RMM readChunks")));
306 std::set<global_ordinal_type> diagset;
312 typename Distribution<global_ordinal_type,scalar_type>::NZindex_t;
315 const int maxLineLength = 81;
316 char *buffer =
new char[chunkSize*maxLineLength+1];
322 auto timerRead = Teuchos::TimeMonitor::getNewTimer(
"RMM readNonzeros");
323 auto timerSelect = Teuchos::TimeMonitor::getNewTimer(
"RMM selectNonzeros");
325 Teuchos::RCP<Teuchos::TimeMonitor> innerTimer = Teuchos::null;
326 while (nRead < nNz) {
328 innerTimer = rcp(
new Teuchos::TimeMonitor(*timerRead));
330 if (nNz-nRead > chunkSize) nChunk = chunkSize;
331 else nChunk = (nNz - nRead);
337 for (
size_t i = 0; i < nChunk; i++) {
338 eof = fgets(&buffer[rlen],maxLineLength,fp);
340 std::cout <<
"Unexpected end of matrix file." << std::endl;
344 rlen += strlen(&buffer[rlen]);
350 Teuchos::broadcast<int, size_t>(*comm, 0, 1, &rlen);
351 Teuchos::broadcast<int, char>(*comm, 0, rlen, buffer);
353 buffer[rlen++] =
'\0';
356 innerTimer = Teuchos::null;
357 innerTimer = rcp(
new Teuchos::TimeMonitor(*timerSelect));
360 char *lineptr = buffer;
361 for (rlen = 0; rlen < nChunk; rlen++) {
363 char *next = strchr(lineptr,
'\n');
364 global_ordinal_type I = atol(strtok(lineptr,
" \t\n"))
366 global_ordinal_type J = atol(strtok(NULL,
" \t\n"))
369 scalar_type V = (patternInput ? -1. : atof(strtok(NULL,
" \t\n")));
373 if ((I == J) && ignoreDiagonal)
continue;
375 if (transpose) std::swap<global_ordinal_type>(I,J);
380 if (dist->Mine(I,J,
int(V))) {
381 nzindex_t idx = std::make_pair(I,J);
383 if (requireDiagonal && (I == J)) diagset.insert(I);
389 if (symmetrize && (I != J) && dist->Mine(J,I,
int(V))) {
392 nzindex_t idx = std::make_pair(J,I);
399 if (nRead / 1000000 > nMillion) {
401 if (me == 0) std::cout << nMillion <<
"M ";
405 innerTimer = Teuchos::null;
408 if (verbose && me == 0)
409 std::cout << std::endl << nRead <<
" nonzeros read " << std::endl;
411 if (fp != NULL) fclose(fp);
415 timer = Teuchos::null;
416 timer = rcp(
new Teuchos::TimeMonitor(
417 *Teuchos::TimeMonitor::getNewTimer(
"RMM diagonal")));
422 if (requireDiagonal) {
423 if (dist->DistType() == MMFile) {
427 size_t localss = diagset.size();
429 Teuchos::reduceAll<int, size_t>(*comm, Teuchos::REDUCE_SUM, 1,
430 &localss, &globalss);
431 TEUCHOS_TEST_FOR_EXCEPTION(globalss != nRow, std::logic_error,
432 "File-based nonzero distribution requires all diagonal "
433 <<
"entries to be present in the file. \n"
434 <<
"Number of diagonal entries in file = " << globalss <<
"\n"
435 <<
"Number of matrix rows = " << nRow <<
"\n");
438 for (global_ordinal_type i = 0;
439 i < static_cast<global_ordinal_type>(nRow); i++)
441 if (dist->Mine(i,i)) {
442 if (diagset.find(i) == diagset.end()) {
443 nzindex_t idx = std::make_pair(i,i);
451 std::set<global_ordinal_type>().swap(diagset);
454 timer = Teuchos::null;
509 const std::string &filename,
510 const Teuchos::RCP<
const Teuchos::Comm<int> > &comm,
511 const Teuchos::ParameterList ¶ms,
514 typename Distribution<global_ordinal_type,scalar_type>::LocalNZmap_t &localNZ,
515 Teuchos::RCP<Distribution<global_ordinal_type,scalar_type> > &dist
519 int me = comm->getRank();
521 bool verbose =
false;
523 const Teuchos::ParameterEntry *pe = params.getEntryPtr(
"verbose");
525 verbose = pe->getValue<
bool>(&verbose);
528 size_t chunkSize = 500000;
530 const Teuchos::ParameterEntry *pe = params.getEntryPtr(
"chunkSize");
532 chunkSize = pe->getValue<
size_t>(&chunkSize);
535 bool symmetrize =
false;
537 const Teuchos::ParameterEntry *pe = params.getEntryPtr(
"symmetrize");
539 symmetrize = pe->getValue<
bool>(&symmetrize);
542 bool transpose =
false;
544 const Teuchos::ParameterEntry *pe = params.getEntryPtr(
"transpose");
546 transpose = pe->getValue<
bool>(&transpose);
549 std::string diagonal =
"";
553 const Teuchos::ParameterEntry *pe = params.getEntryPtr(
"diagonal");
555 diagonal = pe->getValue<std::string>(&diagonal);
557 bool ignoreDiagonal = (diagonal ==
"exclude");
558 bool requireDiagonal = (diagonal ==
"require");
560 std::string distribution =
"1D";
562 const Teuchos::ParameterEntry *pe = params.getEntryPtr(
"distribution");
564 distribution = pe->getValue<std::string>(&distribution);
567 if (verbose && me == 0)
568 std::cout <<
"Reading binary file... " << filename << std::endl;
571 size_t dim[3] = {0,0,0};
575 fp = fopen(filename.c_str(),
"rb");
578 std::cout <<
"Error: cannot open file " << filename << std::endl;
583 unsigned long long ne = 0;
584 if (fread(&nv,
sizeof(
unsigned int), 1, fp) != 1)
585 throw std::runtime_error(
"Error: bad number of read values.");
586 if (fread(&ne,
sizeof(
unsigned long long), 1, fp) != 1)
587 throw std::runtime_error(
"Error: bad number of read values.");
597 Teuchos::broadcast<int, size_t>(*comm, 0, 3, dim);
598 if (dim[0] == 0 || dim[1] == 0) {
599 throw std::runtime_error(
"Error: bad matrix header information");
606 if (verbose && me == 0)
607 std::cout <<
"Binary file... "
608 <<
"\n symmetrize = " << symmetrize
609 <<
"\n transpose = " << transpose
610 <<
"\n change diagonal = " << diagonal
611 <<
"\n distribution = " << distribution
615 dist = buildDistribution<global_ordinal_type,scalar_type>(distribution,
619 std::set<global_ordinal_type> diagset;
625 typename Distribution<global_ordinal_type,scalar_type>::NZindex_t;
628 unsigned int *buffer =
new unsigned int[chunkSize*2];
633 const scalar_type ONE = Teuchos::ScalarTraits<scalar_type>::one();
637 while (nRead < nNz) {
638 if (nNz-nRead > chunkSize) nChunk = chunkSize;
639 else nChunk = (nNz - nRead);
645 for (
size_t i = 0; i < nChunk; i++) {
646 ret = fread(&buffer[rlen],
sizeof(
unsigned int), 2, fp);
648 std::cout <<
"Unexpected end of matrix file." << std::endl;
657 Teuchos::broadcast<int, size_t>(*comm, 0, 1, &rlen);
658 Teuchos::broadcast<int, unsigned int>(*comm, 0, rlen, buffer);
663 for (rlen = 0; rlen < nChunk; rlen++) {
665 global_ordinal_type I = buffer[2*rlen]-1;
666 global_ordinal_type J = buffer[2*rlen+1]-1;
669 if ((I == J) && ignoreDiagonal)
continue;
671 if (transpose) std::swap<global_ordinal_type>(I,J);
676 if (dist->Mine(I,J,ONE)) {
677 nzindex_t idx = std::make_pair(I,J);
680 if (requireDiagonal && (I == J)) diagset.insert(I);
686 if (symmetrize && (I != J) && dist->Mine(J,I,ONE)) {
689 nzindex_t idx = std::make_pair(J,I);
696 if (nRead / 1000000 > nMillion) {
698 if (me == 0) std::cout << nMillion <<
"M ";
703 if (verbose && me == 0)
704 std::cout << std::endl << nRead <<
" nonzeros read " << std::endl;
706 if (fp != NULL) fclose(fp);
711 if (requireDiagonal) {
712 if (dist->DistType() == MMFile) {
716 size_t localss = diagset.size();
718 Teuchos::reduceAll<int, size_t>(*comm, Teuchos::REDUCE_SUM, 1,
719 &localss, &globalss);
720 TEUCHOS_TEST_FOR_EXCEPTION(globalss != nRow, std::logic_error,
721 "File-based nonzero distribution requires all diagonal "
722 <<
"entries to be present in the file. \n"
723 <<
"Number of diagonal entries in file = " << globalss <<
"\n"
724 <<
"Number of matrix rows = " << nRow <<
"\n");
727 for (global_ordinal_type i = 0;
728 i < static_cast<global_ordinal_type>(nRow); i++)
730 if (dist->Mine(i,i)) {
731 if (diagset.find(i) == diagset.end()) {
732 nzindex_t idx = std::make_pair(i,i);
740 std::set<global_ordinal_type>().swap(diagset);
772 readPerProcessBinary(
773 const std::string &filename,
774 const Teuchos::RCP<
const Teuchos::Comm<int> > &comm,
775 const Teuchos::ParameterList ¶ms,
778 typename Distribution<global_ordinal_type,scalar_type>::LocalNZmap_t &localNZ,
779 Teuchos::RCP<Distribution<global_ordinal_type,scalar_type> > &dist,
780 unsigned int* &buffer,
785 int me = comm->getRank();
787 bool verbose =
false;
789 const Teuchos::ParameterEntry *pe = params.getEntryPtr(
"verbose");
791 verbose = pe->getValue<
bool>(&verbose);
794 std::string distribution =
"1D";
796 const Teuchos::ParameterEntry *pe = params.getEntryPtr(
"distribution");
798 distribution = pe->getValue<std::string>(&distribution);
801 if (verbose && me == 0)
802 std::cout <<
"Reading per-process binary files... " << filename << std::endl;
805 std::string rankFileName = filename +
"." + std::to_string(me) +
".cooBin";
808 fp = fopen(rankFileName.c_str(),
"rb");
810 std::cout <<
"Error: cannot open file " << filename << std::endl;
811 throw std::runtime_error(
"Error: non-existing input file: " + rankFileName);
815 unsigned int globalNumRows = 0, globalNumCols = 0;
816 unsigned long long localNumNonzeros = 0;
817 if (fread(&globalNumRows,
sizeof(
unsigned int), 1, fp) != 1)
818 throw std::runtime_error(
"Error: bad number of read values.");
819 if (fread(&globalNumCols,
sizeof(
unsigned int), 1, fp) != 1)
820 throw std::runtime_error(
"Error: bad number of read values.");
821 if (fread(&localNumNonzeros,
sizeof(
unsigned long long), 1, fp) != 1)
822 throw std::runtime_error(
"Error: bad number of read values.");
824 nRow =
static_cast<size_t>(globalNumRows);
825 nCol =
static_cast<size_t>(globalNumCols);
826 nNz =
static_cast<size_t>(localNumNonzeros);
830 buffer =
new unsigned int[nNz*2];
833 size_t ret = fread(buffer,
sizeof(
unsigned int), 2*nNz, fp);
835 std::cout <<
"Unexpected end of matrix file: " << rankFileName << std::endl;
841 if (fp != NULL) fclose(fp);
845 if(verbose && me == 0)
846 std::cout <<
"All ranks finished reading their nonzeros from their individual files\n";
849 dist = buildDistribution<global_ordinal_type,scalar_type>(distribution,
857 static Teuchos::RCP<sparse_matrix_type>
859 const std::string &filename,
860 const Teuchos::RCP<
const Teuchos::Comm<int> > &comm,
861 const Teuchos::ParameterList ¶ms
864 Teuchos::RCP<Distribution<global_ordinal_type,scalar_type> > dist;
865 return readSparseFile(filename, comm, params, dist);
871 static Teuchos::RCP<sparse_matrix_type>
873 const std::string &filename,
874 const Teuchos::RCP<
const Teuchos::Comm<int> > &comm,
875 const Teuchos::ParameterList ¶ms,
876 Teuchos::RCP<Distribution<global_ordinal_type,scalar_type> > &dist
879 bool useTimers =
false;
881 const Teuchos::ParameterEntry *pe = params.getEntryPtr(
"useTimers");
883 useTimers = pe->getValue<
bool>(&useTimers);
886 Teuchos::RCP<Teuchos::TimeMonitor> timer = Teuchos::null;
888 timer = rcp(
new Teuchos::TimeMonitor(
889 *Teuchos::TimeMonitor::getNewTimer(
"RSF parameterSetup")));
891 int me = comm->getRank();
896 bool verbose =
false;
898 const Teuchos::ParameterEntry *pe = params.getEntryPtr(
"verbose");
900 verbose = pe->getValue<
bool>(&verbose);
903 bool callFillComplete =
true;
905 const Teuchos::ParameterEntry *pe = params.getEntryPtr(
"callFillComplete");
907 callFillComplete = pe->getValue<
bool>(&callFillComplete);
918 typename Distribution<global_ordinal_type,scalar_type>::LocalNZmap_t;
919 localNZmap_t localNZ;
923 const Teuchos::ParameterEntry *pe = params.getEntryPtr(
"binary");
925 binary = pe->getValue<
bool>(&binary);
928 bool readPerProcess =
false;
930 const Teuchos::ParameterEntry *pe = params.getEntryPtr(
"readPerProcess");
932 readPerProcess = pe->getValue<
bool>(&readPerProcess);
936 const char *timername = (binary?
"RSF readBinary":
"RSF readMatrixMarket");
937 timer = Teuchos::null;
938 timer = rcp(
new Teuchos::TimeMonitor(
939 *Teuchos::TimeMonitor::getNewTimer(timername)));
943 size_t nRow = 0, nCol = 0;
944 unsigned int *buffer=0;
size_t nNz = 0;
947 readPerProcessBinary(filename, comm, params, nRow, nCol, localNZ, dist, buffer, nNz);
949 readBinary(filename, comm, params, nRow, nCol, localNZ, dist);
952 readMatrixMarket(filename, comm, params, nRow, nCol, localNZ, dist);
954 if(readPerProcess ==
false){
959 timer = Teuchos::null;
960 timer = rcp(
new Teuchos::TimeMonitor(
961 *Teuchos::TimeMonitor::getNewTimer(
"RSF redistribute")));
964 dist->Redistribute(localNZ);
968 timer = Teuchos::null;
969 timer = rcp(
new Teuchos::TimeMonitor(
970 *Teuchos::TimeMonitor::getNewTimer(
"RSF nonzerosConstruction")));
975 if (verbose && me == 0)
976 std::cout << std::endl <<
"Constructing the matrix" << std::endl;
978 Teuchos::Array<global_ordinal_type> rowIdx;
979 Teuchos::Array<size_t> nnzPerRow;
980 Teuchos::Array<global_ordinal_type> colIdx;
981 Teuchos::Array<scalar_type> val;
982 Teuchos::Array<size_t> offsets;
985 global_ordinal_type prevI = std::numeric_limits<global_ordinal_type>::max();
986 for (
size_t it = 0; it < nNz; it++){
987 global_ordinal_type I = buffer[2*it]-1;
988 global_ordinal_type J = buffer[2*it+1]-1;
992 nnzPerRow.push_back(0);
1001 global_ordinal_type prevI = std::numeric_limits<global_ordinal_type>::max();
1002 for (
auto it = localNZ.begin(); it != localNZ.end(); it++) {
1003 global_ordinal_type I = it->first.first;
1004 global_ordinal_type J = it->first.second;
1005 scalar_type V = it->second;
1008 rowIdx.push_back(I);
1009 nnzPerRow.push_back(0);
1012 colIdx.push_back(J);
1017 localNZmap_t().swap(localNZ);
1021 offsets.resize(rowIdx.size() + 1);
1023 for (
size_t row = 0; row < static_cast<size_t>(rowIdx.size()); row++)
1024 offsets[row+1] = offsets[row] + nnzPerRow[row];
1027 timer = Teuchos::null;
1028 timer = rcp(
new Teuchos::TimeMonitor(
1029 *Teuchos::TimeMonitor::getNewTimer(
"RSF insertNonzeros")));
1033 size_t dummy = Teuchos::OrdinalTraits<Tpetra::global_size_t>::invalid();
1034 Teuchos::RCP<const Tpetra::Map<> > rowMap =
1037 Teuchos::RCP<sparse_matrix_type> A =
1038 rcp(
new sparse_matrix_type(rowMap, nnzPerRow()));
1041 if (verbose && me == 0)
1042 std::cout <<
"Inserting global values" << std::endl;
1045 const scalar_type ONE = Teuchos::ScalarTraits<scalar_type>::one();
1046 for (
int i = 0; i < rowIdx.size(); i++) {
1047 size_t nnz = nnzPerRow[i];
1048 size_t off = offsets[i];
1049 val.assign(nnz, ONE);
1052 A->insertGlobalValues(rowIdx[i], colIdx(off, nnz), val());
1056 for (
int i = 0; i < rowIdx.size(); i++) {
1057 size_t nnz = nnzPerRow[i];
1058 size_t off = offsets[i];
1059 A->insertGlobalValues(rowIdx[i], colIdx(off, nnz), val(off, nnz));
1064 Teuchos::Array<size_t>().swap(nnzPerRow);
1065 Teuchos::Array<size_t>().swap(offsets);
1066 Teuchos::Array<global_ordinal_type>().swap(rowIdx);
1067 Teuchos::Array<global_ordinal_type>().swap(colIdx);
1068 Teuchos::Array<scalar_type>().swap(val);
1071 timer = Teuchos::null;
1073 if (callFillComplete) {
1075 if (verbose && me == 0)
1076 std::cout <<
"Building vector maps" << std::endl;
1079 timer = Teuchos::null;
1080 timer = rcp(
new Teuchos::TimeMonitor(
1081 *Teuchos::TimeMonitor::getNewTimer(
"RSF buildVectorMaps")));
1085 Teuchos::Array<global_ordinal_type> vectorSet;
1086 for (global_ordinal_type i = 0;
1087 i < static_cast<global_ordinal_type>(nCol); i++)
1088 if (dist->VecMine(i)) vectorSet.push_back(i);
1090 dummy = Teuchos::OrdinalTraits<Tpetra::global_size_t>::invalid();
1091 Teuchos::RCP<const Tpetra::Map<> > domainMap =
1092 Teuchos::rcp(
new Tpetra::Map<>(dummy, vectorSet(), 0, comm));
1094 Teuchos::Array<global_ordinal_type>().swap(vectorSet);
1097 for (global_ordinal_type i = 0;
1098 i < static_cast<global_ordinal_type>(nRow); i++)
1099 if (dist->VecMine(i)) vectorSet.push_back(i);
1101 dummy = Teuchos::OrdinalTraits<Tpetra::global_size_t>::invalid();
1102 Teuchos::RCP<const Tpetra::Map<> > rangeMap =
1103 Teuchos::rcp(
new Tpetra::Map<>(dummy, vectorSet(), 0, comm));
1105 Teuchos::Array<global_ordinal_type>().swap(vectorSet);
1109 timer = Teuchos::null;
1110 timer = rcp(
new Teuchos::TimeMonitor(
1111 *Teuchos::TimeMonitor::getNewTimer(
"RSF fillComplete")));
1114 if (verbose && me == 0)
1115 std::cout <<
"Calling fillComplete" << std::endl;
1117 A->fillComplete(domainMap, rangeMap);
1120 timer = Teuchos::null;
1123 std::cout <<
"\nRank " << A->getComm()->getRank()
1124 <<
" nRows " << A->getLocalNumRows()
1125 <<
" minRow " << A->getRowMap()->getMinGlobalIndex()
1126 <<
" maxRow " << A->getRowMap()->getMaxGlobalIndex()
1127 <<
"\nRank " << A->getComm()->getRank()
1128 <<
" nCols " << A->getLocalNumCols()
1129 <<
" minCol " << A->getColMap()->getMinGlobalIndex()
1130 <<
" maxCol " << A->getColMap()->getMaxGlobalIndex()
1131 <<
"\nRank " << A->getComm()->getRank()
1132 <<
" nDomain " << A->getDomainMap()->getLocalNumElements()
1133 <<
" minDomain " << A->getDomainMap()->getMinGlobalIndex()
1134 <<
" maxDomain " << A->getDomainMap()->getMaxGlobalIndex()
1135 <<
"\nRank " << A->getComm()->getRank()
1136 <<
" nRange " << A->getRangeMap()->getLocalNumElements()
1137 <<
" minRange " << A->getRangeMap()->getMinGlobalIndex()
1138 <<
" maxRange " << A->getRangeMap()->getMaxGlobalIndex()
1139 <<
"\nRank " << A->getComm()->getRank()
1140 <<
" nEntries " << A->getLocalNumEntries()
A parallel distribution of indices over processes.