Epetra Package Browser (Single Doxygen Collection)  Development
Epetra_CrsGraphData.cpp
Go to the documentation of this file.
1 /*
2 //@HEADER
3 // ************************************************************************
4 //
5 // Epetra: Linear Algebra Services Package
6 // Copyright 2011 Sandia Corporation
7 //
8 // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
9 // the U.S. Government retains certain rights in this software.
10 //
11 // Redistribution and use in source and binary forms, with or without
12 // modification, are permitted provided that the following conditions are
13 // met:
14 //
15 // 1. Redistributions of source code must retain the above copyright
16 // notice, this list of conditions and the following disclaimer.
17 //
18 // 2. Redistributions in binary form must reproduce the above copyright
19 // notice, this list of conditions and the following disclaimer in the
20 // documentation and/or other materials provided with the distribution.
21 //
22 // 3. Neither the name of the Corporation nor the names of the
23 // contributors may be used to endorse or promote products derived from
24 // this software without specific prior written permission.
25 //
26 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
27 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
30 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
31 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
32 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
33 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
34 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
35 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
36 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37 //
38 // Questions? Contact Michael A. Heroux (maherou@sandia.gov)
39 //
40 // ************************************************************************
41 //@HEADER
42 */
43 
44 #include "Epetra_ConfigDefs.h"
45 #include "Epetra_CrsGraphData.h"
46 #include "Epetra_Import.h"
47 #include "Epetra_Export.h"
48 //#include "Epetra_ConfigDefs.h" //DATA_DEBUG
49 
50 //=============================================================================
52  // maps
53  : RowMap_(RowMap),
54  ColMap_(RowMap),
55  DomainMap_(RowMap),
56  RangeMap_(RowMap),
57  // importer & exporter
58  Importer_(0),
59  Exporter_(0),
60  // booleans
61  HaveColMap_(false),
62  Filled_(false),
63  Allocated_(false),
64  // for non-static profile, we insert always into sorted lists, so the
65  // graph will always be sorted. The same holds for the redundancies.
66  Sorted_(!StaticProfile),
67  StorageOptimized_(false),
68  NoRedundancies_(!StaticProfile),
69  IndicesAreGlobal_(false),
70  IndicesAreLocal_(false),
71  IndicesAreContiguous_(false),
72  LowerTriangular_(true),
73  UpperTriangular_(true),
74  NoDiagonal_(true),
75  GlobalConstantsComputed_(false),
76  StaticProfile_(StaticProfile),
77  SortGhostsAssociatedWithEachProcessor_(false),
78 
79  // ints
80  IndexBase_(RowMap.IndexBase64()),
81  NumGlobalEntries_(0),
82  NumGlobalBlockRows_(RowMap.NumGlobalElements64()),
83  NumGlobalBlockCols_(NumGlobalBlockRows_),
84  NumGlobalBlockDiagonals_(0),
85  NumMyEntries_(0),
86  NumMyBlockRows_(RowMap.NumMyElements()),
87  NumMyBlockCols_(NumMyBlockRows_),
88  NumMyBlockDiagonals_(0),
89  MaxRowDim_(RowMap.MaxElementSize()),
90  MaxColDim_(MaxRowDim_),
91  GlobalMaxRowDim_(RowMap.MaxElementSize()),
92  GlobalMaxColDim_(GlobalMaxRowDim_),
93  MaxNumNonzeros_(0),
94  GlobalMaxNumNonzeros_(0),
95  NumGlobalNonzeros_(0),
96  NumGlobalRows_(RowMap.NumGlobalPoints64()),
97  NumGlobalCols_(NumGlobalRows_),
98  NumGlobalDiagonals_(0),
99  NumMyNonzeros_(0),
100  NumMyRows_(RowMap.NumMyPoints()),
101  NumMyCols_(NumMyRows_),
102  NumMyDiagonals_(0),
103  MaxNumIndices_(0),
104  GlobalMaxNumIndices_(0),
105  NumTempColIndices_(0),
106  NumAllocatedIndicesPerRow_(0),
107  NumIndicesPerRow_(0),
108  IndexOffset_(0),
109  CV_(CV),
110  data(0)
111 #ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
112  ,LL_data(0)
113 #endif
114 {
115  if(RowMap.GlobalIndicesInt() == false && RowMap.GlobalIndicesLongLong() == false)
116  throw "Epetra_CrsGraphData::Epetra_CrsGraphData: cannot be called without any index type for RowMap";
117 
118  data = new IndexData<int>(NumMyBlockRows_, ! StaticProfile);
119 #ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
120  LL_data = new IndexData<long long>(RowMap.GlobalIndicesLongLong() ? NumMyBlockRows_ : 0, ! StaticProfile);
121 #endif
122  //cout << "--CRSGD created(rowmap ctr), addr: " << this << std::endl; //DATA_DEBUG
123 }
124 
125 //=============================================================================
127  const Epetra_BlockMap& RowMap,
128  const Epetra_BlockMap& ColMap, bool StaticProfile)
129  // maps
130  : RowMap_(RowMap),
131  ColMap_(ColMap),
132  DomainMap_(ColMap),
133  RangeMap_(RowMap),
134  // importer & exporter
135  Importer_(0),
136  Exporter_(0),
137  // booleans
138  HaveColMap_(true),
139  Filled_(false),
140  Allocated_(false),
141  Sorted_(!StaticProfile),
142  StorageOptimized_(false),
143  NoRedundancies_(!StaticProfile),
144  IndicesAreGlobal_(false),
145  IndicesAreLocal_(false),
146  IndicesAreContiguous_(false),
147  LowerTriangular_(true),
148  UpperTriangular_(true),
149  NoDiagonal_(true),
150  GlobalConstantsComputed_(false),
151  StaticProfile_(StaticProfile),
152  SortGhostsAssociatedWithEachProcessor_(false),
153  // ints
154  IndexBase_(RowMap.IndexBase64()),
155  NumGlobalEntries_(0),
156  NumGlobalBlockRows_(RowMap.NumGlobalElements64()),
157  NumGlobalBlockCols_(ColMap.NumGlobalElements64()),
158  NumGlobalBlockDiagonals_(0),
159  NumMyEntries_(0),
160  NumMyBlockRows_(RowMap.NumMyElements()),
161  NumMyBlockCols_(ColMap.NumMyElements()),
162  NumMyBlockDiagonals_(0),
163  MaxRowDim_(RowMap.MaxElementSize()),
164  MaxColDim_(ColMap.MaxElementSize()),
165  GlobalMaxRowDim_(RowMap.MaxElementSize()),
166  GlobalMaxColDim_(ColMap.MaxElementSize()),
167  MaxNumNonzeros_(0),
168  GlobalMaxNumNonzeros_(0),
169  NumGlobalNonzeros_(0),
170  NumGlobalRows_(RowMap.NumGlobalPoints64()),
171  NumGlobalCols_(ColMap.NumGlobalPoints64()),
172  NumGlobalDiagonals_(0),
173  NumMyNonzeros_(0),
174  NumMyRows_(RowMap.NumMyPoints()),
175  NumMyCols_(ColMap.NumMyPoints()),
176  NumMyDiagonals_(0),
177  MaxNumIndices_(0),
178  GlobalMaxNumIndices_(0),
179  NumTempColIndices_(0),
180  NumAllocatedIndicesPerRow_(0),
181  NumIndicesPerRow_(0),
182  IndexOffset_(0),
183  CV_(CV),
184  data(0)
185 #ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
186  ,LL_data(0)
187 #endif
188 {
189  if(RowMap.GlobalIndicesInt() == false && RowMap.GlobalIndicesLongLong() == false)
190  throw "Epetra_CrsGraphData::Epetra_CrsGraphData: cannot be called without any index type for RowMap";
191 
192  if(!RowMap.GlobalIndicesTypeMatch(ColMap))
193  throw "Epetra_CrsGraphData::Epetra_CrsGraphData: cannot be called with different indices types for RowMap and ColMap";
194 
195  data = new IndexData<int>(NumMyBlockRows_, ! StaticProfile);
196 #ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
197  LL_data = new IndexData<long long>(RowMap.GlobalIndicesLongLong() ? NumMyBlockRows_ : 0, ! StaticProfile);
198 #endif
199  //cout << "--CRSGD created(rowmap&colmap ctr), addr: " << this << std::endl; //DATA_DEBUG
200 }
201 
202 //=============================================================================
204 
205  if(data->Indices_ != 0 && !StorageOptimized_) {
206  for (int i=0; i<NumMyBlockRows_; i++) {
207  data->Indices_[i] = 0;
208  }
209  delete[] data->Indices_;
210  data->Indices_ = 0;
211  }
212 
213 #ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
214  if(LL_data->Indices_ != 0 && !StorageOptimized_) {
215  for (int i=0; i<NumMyBlockRows_; i++) {
216  LL_data->Indices_[i] = 0;
217  }
218  delete[] LL_data->Indices_;
219  LL_data->Indices_ = 0;
220  }
221 #endif
222 
223  if (data->TempColIndices_ != 0) {
224  delete [] data->TempColIndices_;
225  data->TempColIndices_ = 0;
226  }
227 
228 #ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
229  if (LL_data->TempColIndices_ != 0) {
230  delete [] LL_data->TempColIndices_;
232  }
233 #endif
234 
235  delete data;
236 #ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
237  delete LL_data;
238 #endif
239 
240  if(Importer_ != 0) {
241  delete Importer_;
242  Importer_ = 0;
243  }
244  if(Exporter_ != 0) {
245  delete Exporter_;
246  Importer_ = 0;
247  }
248 
249  NumMyBlockRows_ = 0; // are these needed?
250  Filled_ = false; // they're about to go out of scope, after all
251  Allocated_ = false;
252 
253  //cout << "--CRSGD destroyed, addr: " << this << std::endl; //DATA_DEBUG
254 }
255 
256 //==========================================================================
258  // Create Import object for use by matrix classes. This is only needed if ColMap and DomainMap are different
259  if (!ColMap_.SameAs(DomainMap_)) {
260  if (Importer_ != 0) {
261  delete Importer_;
262  Importer_ = 0;
263  }
265  }
266 
267  // Now see if we need to define an export map. This is only needed if RowMap and RangeMap are different
268  if (!RowMap_.SameAs(RangeMap_)) {
269  if (Exporter_ != 0) {
270  delete Exporter_;
271  Exporter_ = 0;
272  }
273  Exporter_ = new Epetra_Export(RowMap_, RangeMap_); // Create Export object.
274  }
275 
276  return(0);
277 }
278 
279 //==========================================================================
280 int Epetra_CrsGraphData::ReAllocateAndCast(char*& UserPtr, int& Length, const int IntPacketSizeTimesNumTrans) {
281  if(IntPacketSizeTimesNumTrans > Length) {
282  if(Length > 0)
283  delete[] UserPtr;
284  Length = IntPacketSizeTimesNumTrans;
285  int* newPtr = new int[Length];
286  UserPtr = reinterpret_cast<char*> (newPtr);
287  }
288  return(0);
289 }
290 
291 //==========================================================================
292 void Epetra_CrsGraphData::Print(std::ostream& os, int level) const {
293  bool four_bit = (level >= 4); // 4-bit = BlockMaps
294  bool two_bit = ((level % 4) >= 2); // 2-bit = Indices
295  bool one_bit = ((level % 2) == 1); // 1-bit = Everything else
296 
297  os << "\n***** CrsGraphData (output level " << level << ") *****" << std::endl;
298 
299  if(four_bit) {
300  os << "RowMap_:\n" << RowMap_ << std::endl;
301  os << "ColMap_:\n" << ColMap_ << std::endl;
302  os << "DomainMap_:\n" << DomainMap_ << std::endl;
303  os << "RangeMap_:\n" << RangeMap_ << std::endl;
304  }
305 
306  if(one_bit) {
307  os.width(26); os << "HaveColMap_: " << HaveColMap_;
308  os.width(25); os << "Filled_: " << Filled_;
309  os.width(25); os << "Allocated_: " << Allocated_;
310  os.width(25); os << "Sorted_: " << Sorted_ << std::endl;
311  os.width(26); os << "StorageOptimized_: " << StorageOptimized_;
312  os.width(25); os << "SortGhostsAssociatedWithEachProcessor_: " << SortGhostsAssociatedWithEachProcessor_;
313  os.width(25); os << "NoRedundancies_: " << NoRedundancies_;
314  os.width(25); os << "IndicesAreGlobal_: " << IndicesAreGlobal_;
315  os.width(25); os << "IndicesAreLocal_: " << IndicesAreLocal_ << std::endl;
316  os.width(26); os << "IndicesAreContiguous_: " << IndicesAreContiguous_;
317  os.width(25); os << "LowerTriangular_: " << LowerTriangular_;
318  os.width(25); os << "UpperTriangular_: " << UpperTriangular_;
319  os.width(25); os << "NoDiagonal_: " << NoDiagonal_ << std::endl;
320  os.width(25); os << "GlobalConstantsComputed_: " << GlobalConstantsComputed_ << std::endl;
321  os.width(25); os << "StaticProfile_: " << StaticProfile_ << std::endl << std::endl;
322 
323  os.width(10); os << "NGBR_: " << NumGlobalBlockRows_;
324  os.width(10); os << "NGBC_: " << NumGlobalBlockCols_;
325  os.width(10); os << "NGBD_: " << NumGlobalBlockDiagonals_;
326  os.width(10); os << "NGE_: " << NumGlobalEntries_;
327  os.width(10); os << "NGR_: " << NumGlobalRows_;
328  os.width(10); os << "NGC_: " << NumGlobalCols_;
329  os.width(10); os << "NGD_: " << NumGlobalDiagonals_;
330  os.width(10); os << "NGN_: " << NumGlobalNonzeros_;
331  os.width(10); os << "IB_: " << IndexBase_ << std::endl;
332  os.width(10); os << "GMRD_: " << GlobalMaxRowDim_;
333  os.width(11); os << "GMCD_: " << GlobalMaxColDim_;
334  os.width(11); os << "GMNI_: " << GlobalMaxNumIndices_;
335  os.width(11); os << "NMBR_: " << NumMyBlockRows_;
336  os.width(10); os << "NMBC_: " << NumMyBlockCols_;
337  os.width(10); os << "NMBD_: " << NumMyBlockDiagonals_;
338  os.width(10); os << "NME_: " << NumMyEntries_;
339  os.width(10); os << "NMR_: " << NumMyRows_;
340  os.width(10); os << "CV_: " << CV_ << std::endl;
341  os.width(10); os << "NMC_: " << NumMyCols_;
342  os.width(10); os << "NMD_: " << NumMyDiagonals_;
343  os.width(10); os << "NMN_: " << NumMyNonzeros_;
344  os.width(10); os << "MRD_: " << MaxRowDim_;
345  os.width(11); os << "MCD_: " << MaxColDim_;
346  os.width(11); os << "MNI_: " << MaxNumIndices_;
347  os.width(11); os << "MNN_: " << MaxNumNonzeros_;
348  os.width(11); os << "GMNN_: " << GlobalMaxNumNonzeros_;
349  os.width(11); os << "RC: " << ReferenceCount() << std::endl << std::endl;
350 
351  os << "NIPR_: " << NumIndicesPerRow_ << std::endl;
352  os << "NAIPR_: " << NumAllocatedIndicesPerRow_ << std::endl;
353  os << "IndexOffset_: " << IndexOffset_ << std::endl;
355  os << "All_Indices_: " << data->All_Indices_ << std::endl;
356 
358 #ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
359  os << "All_Indices_: " << LL_data->All_Indices_ << std::endl;
360 #else
361  throw "Epetra_CrsGraphData::Print: GlobalIndicesLongLong but no long long API";
362 #endif
363  }
364 
365  if(two_bit) {
367  {
368  os << "Indices_: " << data->Indices_ << std::endl;
369  if(data->Indices_ != 0) {
370  for(int i = 0; i < NumMyBlockRows_; i++) {
371  os << "Indices_[" << i << "]: (" << data->Indices_[i] << ") ";
372  if(data->Indices_[i] != 0) {
373  for(int j = 0; j < NumAllocatedIndicesPerRow_[i]; j++)
374  os << data->Indices_[i][j] << " ";
375  }
376  os << std::endl;
377  }
378  }
379  }
380 
382  {
383 #ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
384  os << "Indices_: " << LL_data->Indices_ << std::endl;
385  if(LL_data->Indices_ != 0) {
386  for(int i = 0; i < NumMyBlockRows_; i++) {
387  os << "Indices_[" << i << "]: (" << LL_data->Indices_[i] << ") ";
388  if(LL_data->Indices_[i] != 0) {
389  for(int j = 0; j < NumAllocatedIndicesPerRow_[i]; j++)
390  os << LL_data->Indices_[i][j] << " ";
391  }
392  os << std::endl;
393  }
394  }
395 #else
396  throw "Epetra_CrsGraphData::Print: GlobalIndicesLongLong but no long long API";
397 #endif
398  }
399  }
400 
401  os << "***** End CrsGraphData *****" << std::endl;
402 }
403 
404 
405 //==========================================================================
406 template<typename int_type>
407 void
409 {
410  // first check the last element (or if line is still empty)
411  if ( (entries_.size()==0) || ( entries_.back() < Col) )
412  {
413  entries_.push_back(Col);
414  return;
415  }
416 
417  // do a binary search to find the place where to insert:
418  typename std::vector<int_type>::iterator it = std::lower_bound(entries_.begin(),
419  entries_.end(),
420  Col);
421 
422  // If this entry is a duplicate, exit immediately
423  if (*it == Col)
424  return;
425 
426  // Insert at the right place in the vector. Vector grows automatically to
427  // fit elements. Always doubles its size.
428  entries_.insert(it, Col);
429 }
430 
431 
432 //==========================================================================
433 template<typename int_type>
434 void
436  const int_type *Indices)
437 {
438  if (numCols == 0)
439  return;
440 
441  // Check whether the indices are sorted. Can do more efficient then.
442  bool indicesAreSorted = true;
443  for (int i=1; i<numCols; ++i)
444  if (Indices[i] <= Indices[i-1]) {
445  indicesAreSorted = false;
446  break;
447  }
448 
449  if (indicesAreSorted && numCols > 3) {
450  const int_type * curInput = &Indices[0];
451  int_type col = *curInput;
452  const int_type * endInput = &Indices[numCols];
453 
454  // easy case: list of entries is empty or all entries are smaller than
455  // the ones to be inserted
456  if (entries_.size() == 0 || entries_.back() < col)
457  {
458  entries_.insert(entries_.end(), &Indices[0], &Indices[numCols]);
459  return;
460  }
461 
462  // find a possible insertion point for the first entry. check whether
463  // the first entry is a duplicate before actually doing something.
464  typename std::vector<int_type>::iterator it =
465  std::lower_bound(entries_.begin(), entries_.end(), col);
466  while (*it == col) {
467  ++curInput;
468  if (curInput == endInput)
469  break;
470  col = *curInput;
471 
472  // check the very next entry in the current array
473  ++it;
474  if (it == entries_.end())
475  break;
476  if (*it > col)
477  break;
478  if (*it == col)
479  continue;
480 
481  // ok, it wasn't the very next one, do a binary search to find the
482  // insert point
483  it = std::lower_bound(it, entries_.end(), col);
484  if (it == entries_.end())
485  break;
486  }
487 
488  // all input entries were duplicates.
489  if (curInput == endInput)
490  return;
491 
492  // Resize vector by just inserting the list at the correct point. Note
493  // that the list will not yet be sorted, but rather have the insert
494  // indices in the middle and the old indices from the list on the
495  // end. Next we will have to merge the two lists.
496  const int pos1 = (int) (it - entries_.begin());
497  entries_.insert (it, curInput, endInput);
498  it = entries_.begin() + pos1;
499 
500  // Now merge the two lists...
501  typename std::vector<int_type>::iterator it2 = it + (endInput - curInput);
502 
503  // As long as there are indices both in the end of the entries list and
504  // in the input list, always continue with the smaller index.
505  while (curInput != endInput && it2 != entries_.end())
506  {
507  if (*curInput < *it2)
508  *it++ = *curInput++;
509  else if (*curInput == *it2)
510  {
511  *it++ = *it2++;
512  ++curInput;
513  }
514  else
515  *it++ = *it2++;
516  }
517  // in case there are indices left in the input list or in the end of
518  // entries, we have to use the entries that are left. Only one of the
519  // two while loops will actually be entered.
520  while (curInput != endInput)
521  *it++ = *curInput++;
522 
523  while (it2 != entries_.end())
524  *it++ = *it2++;
525 
526  // resize and return
527  const int new_size = (int) (it - entries_.begin());
528  entries_.resize (new_size);
529  return;
530  }
531 
532  // for unsorted or just a few indices, go to the one-by-one entry
533  // function.
534  for (int i=0; i<numCols; ++i)
535  AddEntry(Indices[i]);
536 }
537 
538 // explicit instantiation.
539 template void Epetra_CrsGraphData::EntriesInOneRow<int>::AddEntry(const int Col);
540 template void Epetra_CrsGraphData::EntriesInOneRow<int>::AddEntries(const int numCols, const int *Indices);
541 
542 #ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
543 template void Epetra_CrsGraphData::EntriesInOneRow<long long>::AddEntry(const long long Col);
544 template void Epetra_CrsGraphData::EntriesInOneRow<long long>::AddEntries(const int numCols, const long long *Indices);
545 #endif
const Epetra_Export * Exporter_
int MakeImportExport()
called by FillComplete (and TransformToLocal)
Epetra_BlockMap RangeMap_
Epetra_IntSerialDenseVector NumIndicesPerRow_
int ReferenceCount() const
Get reference count.
Definition: Epetra_Data.cpp:71
bool SameAs(const Epetra_BlockMap &Map) const
Returns true if this and Map are identical maps.
int ReAllocateAndCast(char *&UserPtr, int &Length, const int IntPacketSizeTimesNumTrans)
called by PackAndPrepare
~Epetra_CrsGraphData()
Epetra_CrsGraphData Destructor.
IndexData< long long > * LL_data
Epetra_BlockMap DomainMap_
Epetra_Export: This class builds an export object for efficient exporting of off-processor elements...
Definition: Epetra_Export.h:62
Epetra_LongLongSerialDenseVector All_Indices_
Epetra_Import: This class builds an import object for efficient importing of off-processor elements...
Definition: Epetra_Import.h:63
void AddEntry(const int_type col_num)
Add the given column number to this line.
IndexData< int > * data
Epetra_IntSerialDenseVector NumAllocatedIndicesPerRow_
bool GlobalIndicesInt() const
Returns true if map create with int NumGlobalElements.
void Print(std::ostream &os, int level=3) const
Outputs state of almost all data members. (primarily used for testing purposes).
Epetra_BlockMap: A class for partitioning block element vectors and matrices.
Epetra_IntSerialDenseVector All_Indices_
void AddEntries(const int n_cols, const int_type *col_nums)
Add many entries to one row.
Epetra_CrsGraphData(Epetra_DataAccess CV, const Epetra_BlockMap &RowMap, bool StaticProfile)
Epetra_CrsGraphData Default Constructor.
Epetra_IntSerialDenseVector IndexOffset_
bool GlobalIndicesTypeMatch(const Epetra_BlockMap &other) const
Epetra_DataAccess CV_
const Epetra_Import * Importer_
Epetra_DataAccess
bool GlobalIndicesLongLong() const
Returns true if map create with long long NumGlobalElements.