3#ifndef DUNE_ISTL_MATRIXMARKET_HH
4#define DUNE_ISTL_MATRIXMARKET_HH
22#include <dune/common/exceptions.hh>
23#include <dune/common/fmatrix.hh>
24#include <dune/common/fvector.hh>
25#include <dune/common/hybridutilities.hh>
26#include <dune/common/stdstreams.hh>
27#include <dune/common/simd/simd.hh>
62 namespace MatrixMarketImpl
93 static std::string
str()
174 template<
typename T,
typename A>
179 os<<
"%%MatrixMarket matrix coordinate ";
180 os<<mm_numeric_type<Simd::Scalar<typename Imp::BlockTraits<T>::field_type>>::str()<<
" general"<<std::endl;
184 template<
typename B,
typename A>
189 os<<
"%%MatrixMarket matrix array ";
190 os<<mm_numeric_type<Simd::Scalar<typename Imp::BlockTraits<B>::field_type>>::str()<<
" general"<<std::endl;
194 template<
typename T,
int j>
199 os<<
"%%MatrixMarket matrix array ";
200 os<<mm_numeric_type<T>::str()<<
" general"<<std::endl;
204 template<
typename T,
int i,
int j>
209 os<<
"%%MatrixMarket matrix array ";
210 os<<mm_numeric_type<T>::str()<<
" general"<<std::endl;
225 template<
typename T,
typename A>
229 static_assert(IsNumber<T>::value,
"Only scalar entries are expected here!");
231 static void print(std::ostream& os,
const M&)
233 os<<
"% ISTL_STRUCT blocked ";
234 os<<
"1 1"<<std::endl;
238 template<
typename T,
typename A,
int i>
243 static void print(std::ostream& os,
const M&)
245 os<<
"% ISTL_STRUCT blocked ";
246 os<<i<<
" "<<1<<std::endl;
250 template<
typename T,
typename A>
254 static_assert(IsNumber<T>::value,
"Only scalar entries are expected here!");
256 static void print(std::ostream& os,
const M&)
258 os<<
"% ISTL_STRUCT blocked ";
259 os<<
"1 1"<<std::endl;
263 template<
typename T,
typename A,
int i,
int j>
268 static void print(std::ostream& os,
const M&)
270 os<<
"% ISTL_STRUCT blocked ";
271 os<<i<<
" "<<j<<std::endl;
276 template<
typename T,
int i,
int j>
281 static void print(std::ostream& os,
const M& m)
285 template<
typename T,
int i>
288 typedef FieldVector<T,i>
M;
290 static void print(std::ostream& os,
const M& m)
345 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
360 dverb<<buffer<<std::endl;
362 if(buffer!=
"%%MatrixMarket") {
364 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
375 if(buffer !=
"matrix")
378 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
392 std::transform(buffer.begin(), buffer.end(), buffer.begin(),
399 if(buffer !=
"array")
401 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
408 if(buffer !=
"coordinate")
410 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
416 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
430 std::transform(buffer.begin(), buffer.end(), buffer.begin(),
436 if(buffer !=
"integer")
438 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
447 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
454 if(buffer !=
"complex")
456 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
463 if(buffer !=
"pattern")
465 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
471 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
480 std::transform(buffer.begin(), buffer.end(), buffer.begin(),
486 if(buffer !=
"general")
488 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
495 if(buffer !=
"hermitian")
497 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
503 if(buffer.size()==1) {
504 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
512 if(buffer !=
"symmetric")
514 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
521 if(buffer !=
"skew-symmetric")
523 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
529 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
534 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
537 file.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
543 template<std::
size_t brows, std::
size_t bcols>
544 std::tuple<std::size_t, std::size_t, std::size_t>
547 std::size_t blockrows=rows/brows;
548 std::size_t blockcols=cols/bcols;
549 std::size_t blocksize=brows*bcols;
550 std::size_t blockentries=0;
555 blockentries = entries/blocksize;
break;
557 blockentries = 2*entries/blocksize;
break;
559 blockentries = (2*entries-rows)/blocksize;
break;
561 blockentries = (2*entries-rows)/blocksize;
break;
563 throw Dune::NotImplemented();
565 return std::make_tuple(blockrows, blockcols, blockentries);
644 return is>>data.number;
673 template<
typename D,
int brows,
int bcols>
685 static_assert(IsNumber<T>::value && brows==1 && bcols==1,
"Only scalar entries are expected here!");
686 for (
auto iter=matrix.
begin(); iter!= matrix.
end(); ++iter)
688 auto brow=iter.index();
689 for (
auto siter=rows[brow].begin(); siter != rows[brow].end(); ++siter)
690 (*iter)[siter->index] = siter->number;
703 for (
auto iter=matrix.begin(); iter!= matrix.end(); ++iter)
705 for (
auto brow=iter.index()*brows,
706 browend=iter.index()*brows+brows;
707 brow<browend; ++brow)
709 for (
auto siter=rows[brow].begin(), send=rows[brow].end();
710 siter != send; ++siter)
711 (*iter)[siter->index/bcols][brow%brows][siter->index%bcols]=siter->number;
717 template<
int brows,
int bcols>
727 template<
class T>
struct is_complex<std::complex<T>> : std::true_type {};
731 std::enable_if_t<!is_complex<T>::value, T>
conj(
const T& r){
736 std::enable_if_t<is_complex<T>::value, T>
conj(
const T& r){
744 template<
typename B,
typename A>
753 template<
typename B,
int i,
int j,
typename A>
762 template<
typename T,
typename A,
typename D>
764 std::istream& file, std::size_t entries,
776 std::vector<std::set<IndexData<D> > > rows(matrix.
N()*brows);
778 auto readloop = [&] (
auto symmetryFixup) {
779 for(std::size_t i = 0; i < entries; ++i) {
785 assert(row/bcols<matrix.
N());
787 assert(data.
index/bcols<matrix.
M());
788 rows[row].insert(data);
790 symmetryFixup(row, data);
797 readloop([](
auto...){});
800 readloop([&](
auto row,
auto data) {
802 data_sym.
index = row;
803 rows[data.index].insert(data_sym);
807 readloop([&](
auto row,
auto data) {
809 data_sym.number = -data.number;
810 data_sym.
index = row;
811 rows[data.index].insert(data_sym);
815 readloop([&](
auto row,
auto data) {
817 data_sym.number =
conj(data.number);
818 data_sym.
index = row;
819 rows[data.index].insert(data_sym);
823 DUNE_THROW(Dune::NotImplemented,
824 "Only general, symmetric, skew-symmetric and hermitian is supported right now!");
829 for(
typename Matrix::CreateIterator iter=matrix.
createbegin();
832 for(std::size_t brow=iter.index()*brows, browend=iter.index()*brows+brows;
833 brow<browend; ++brow)
835 typedef typename std::set<IndexData<D> >::const_iterator Siter;
836 for(Siter siter=rows[brow].begin(), send=rows[brow].end();
837 siter != send; ++siter, ++nnz)
838 iter.insert(siter->index/bcols);
847 Setter(rows, matrix);
859 using namespace MatrixMarketImpl;
861 if(!readMatrixMarketBanner(istr, header)) {
862 std::cerr <<
"First line was not a correct Matrix Market banner. Using default:\n"
863 <<
"%%MatrixMarket matrix coordinate real general"<<std::endl;
866 istr.seekg(0, std::ios::beg);
868 header.
type=array_type;
883 template<
typename T,
typename A>
889 for (
int i=0; size>0; ++i, --size)
890 istr>>Simd::lane(lane,vector[i]);
893 template<
typename T,
typename A,
int entries>
899 for(
int i=0; size>0; ++i, --size) {
902 Simd::lane(lane, vector[i/entries][i%entries])=val;
913 template<
typename T,
typename A>
918 using namespace MatrixMarketImpl;
921 std::size_t rows, cols;
923 if(cols!=Simd::lanes<field_type>()) {
924 if(Simd::lanes<field_type>() == 1)
930 if(header.type!=array_type)
934 if constexpr (Dune::IsNumber<T>())
939 auto blocksize = dummy.size();
940 std::size_t size=rows/blocksize;
941 if(size*blocksize!=rows)
947 istr.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
948 for(
size_t l=0;l<Simd::lanes<field_type>();++l){
959 template<
typename T,
typename A>
963 using namespace MatrixMarketImpl;
967 if(!readMatrixMarketBanner(istr, header)) {
968 std::cerr <<
"First line was not a correct Matrix Market banner. Using default:\n"
969 <<
"%%MatrixMarket matrix coordinate real general"<<std::endl;
972 istr.seekg(0, std::ios::beg);
976 std::size_t rows, cols, entries;
992 std::size_t nnz, blockrows, blockcols;
995 constexpr int brows = mm_multipliers<Matrix>::rows;
996 constexpr int bcols = mm_multipliers<Matrix>::cols;
998 std::tie(blockrows, blockcols, nnz) = calculateNNZ<brows, bcols>(rows, cols, entries, header);
1000 istr.ignore(std::numeric_limits<std::streamsize>::max(),
'\n');
1003 matrix.
setSize(blockrows, blockcols);
1006 if(header.type==array_type)
1007 DUNE_THROW(Dune::NotImplemented,
"Array format currently not supported for matrices!");
1009 readSparseEntries(matrix, istr, entries, header, NumericWrapper<typename Matrix::field_type>());
1013 template<
typename B>
1019 if constexpr (IsNumber<B>())
1020 ostr << rowidx <<
" " << colidx <<
" " << entry << std::endl;
1023 for (
auto row=entry.begin(); row != entry.end(); ++row, ++rowidx) {
1025 for (
auto col = row->begin();
col != row->end(); ++
col, ++coli)
1026 ostr<< rowidx<<
" "<<coli<<
" "<<*
col<<std::endl;
1032 template<
typename V>
1034 const std::integral_constant<int,1>&,
1037 ostr<<Simd::lane(lane,entry)<<std::endl;
1041 template<
typename V>
1043 const std::integral_constant<int,0>&,
1046 using namespace MatrixMarketImpl;
1049 const int isnumeric = mm_numeric_type<Simd::Scalar<typename V::block_type>>::is_numeric;
1050 typedef typename V::const_iterator VIter;
1052 for(VIter i=vector.begin(); i != vector.end(); ++i)
1055 std::integral_constant<int,isnumeric>(),
1059 template<
typename T,
typename A>
1062 return vector.size();
1065 template<
typename T,
typename A,
int i>
1068 return vector.size()*i;
1072 template<
typename V>
1074 const std::integral_constant<int,0>&)
1076 using namespace MatrixMarketImpl;
1077 typedef typename V::field_type field_type;
1079 ostr<<
countEntries(vector)<<
" "<<Simd::lanes<field_type>()<<std::endl;
1080 const int isnumeric = mm_numeric_type<Simd::Scalar<V>>::is_numeric;
1081 for(
size_t l=0;l<Simd::lanes<field_type>(); ++l){
1087 template<
typename M>
1090 const std::integral_constant<int,1>&)
1096 typedef typename M::const_iterator riterator;
1097 typedef typename M::ConstColIterator citerator;
1098 for(riterator row=matrix.begin(); row != matrix.end(); ++row)
1099 for(citerator
col = row->begin();
col != row->end(); ++
col)
1109 template<
typename M>
1113 using namespace MatrixMarketImpl;
1116 mm_header_printer<M>::print(ostr);
1117 mm_block_structure_header<M>::print(ostr,matrix);
1134 template<
typename M>
1136 std::string filename,
1139 std::ofstream file(filename.c_str());
1140 file.setf(std::ios::scientific,std::ios::floatfield);
1142 file.precision(prec);
1162 template<
typename M,
typename G,
typename L>
1164 std::string filename,
1166 bool storeIndices=
true,
1172 std::ostringstream rfilename;
1173 rfilename<<filename <<
"_"<<rank<<
".mm";
1174 dverb<< rfilename.str()<<std::endl;
1175 std::ofstream file(rfilename.str().c_str());
1176 file.setf(std::ios::scientific,std::ios::floatfield);
1178 file.precision(prec);
1187 rfilename<<filename<<
"_"<<rank<<
".idx";
1188 file.open(rfilename.str().c_str());
1189 file.setf(std::ios::scientific,std::ios::floatfield);
1191 typedef typename IndexSet::const_iterator Iterator;
1192 for(Iterator iter = comm.
indexSet().begin();
1193 iter != comm.
indexSet().end(); ++iter) {
1194 file << iter->global()<<
" "<<(std::size_t)iter->local()<<
" "
1195 <<(int)iter->local().attribute()<<
" "<<(int)iter->local().isPublic()<<std::endl;
1198 file<<
"neighbours:";
1199 const std::set<int>& neighbours=comm.
remoteIndices().getNeighbours();
1200 typedef std::set<int>::const_iterator SIter;
1201 for(SIter neighbour=neighbours.begin(); neighbour != neighbours.end(); ++neighbour) {
1202 file<<
" "<< *neighbour;
1221 template<
typename M,
typename G,
typename L>
1223 const std::string& filename,
1225 bool readIndices=
true)
1227 using namespace MatrixMarketImpl;
1230 typedef typename LocalIndexT::Attribute Attribute;
1234 std::ostringstream rfilename;
1235 rfilename<<filename <<
"_"<<rank<<
".mm";
1237 file.open(rfilename.str().c_str(), std::ios::in);
1239 DUNE_THROW(IOError,
"Could not open file: " << rfilename.str().c_str());
1250 IndexSet& pis=comm.pis;
1252 rfilename<<filename<<
"_"<<rank<<
".idx";
1253 file.open(rfilename.str().c_str());
1255 DUNE_THROW(InvalidIndexSetState,
"Index set is not empty!");
1258 while(!file.eof() && file.peek()!=
'n') {
1267 pis.add(g,LocalIndexT(l,Attribute(c),b));
1275 if(s!=
"neighbours:")
1278 while(!file.eof()) {
1284 comm.ri.setNeighbours(nb);
1286 comm.ri.template rebuild<false>();
1301 template<
typename M>
1303 const std::string& filename)
1306 file.open(filename.c_str(), std::ios::in);
1308 DUNE_THROW(IOError,
"Could not open file: " << filename);
Some handy generic functions for ISTL matrices.
This file implements a vector space as a tensor product of a given vector space. The number of compon...
Classes providing communication interfaces for overlapping Schwarz methods.
Implementation of the BCRSMatrix class.
Col col
Definition: matrixmatrix.hh:349
auto countNonZeros(const M &, typename std::enable_if_t< Dune::IsNumber< M >::value > *sfinae=nullptr)
Get the number of nonzero fields in the matrix.
Definition: matrixutils.hh:117
void readMatrixMarket(Dune::BlockVector< T, A > &vector, std::istream &istr)
Reads a BlockVector from a matrix market file.
Definition: matrixmarket.hh:914
void storeMatrixMarket(const M &matrix, std::string filename, int prec=default_precision)
Stores a parallel matrix/vector in matrix market format in a file.
Definition: matrixmarket.hh:1135
void loadMatrixMarket(M &matrix, const std::string &filename, OwnerOverlapCopyCommunication< G, L > &comm, bool readIndices=true)
Load a parallel matrix/vector stored in matrix market format.
Definition: matrixmarket.hh:1222
std::size_t countEntries(const BlockVector< T, A > &vector)
Definition: matrixmarket.hh:1060
void writeMatrixMarket(const V &vector, std::ostream &ostr, const std::integral_constant< int, 0 > &)
Definition: matrixmarket.hh:1073
void mm_print_vector_entry(const V &entry, std::ostream &ostr, const std::integral_constant< int, 1 > &, size_t lane)
Definition: matrixmarket.hh:1033
static const int default_precision
Definition: matrixmarket.hh:1122
void mm_read_vector_entries(Dune::BlockVector< T, A > &vector, std::size_t size, std::istream &istr, size_t lane)
Definition: matrixmarket.hh:884
void mm_read_header(std::size_t &rows, std::size_t &cols, MatrixMarketImpl::MMHeader &header, std::istream &istr, bool isVector)
Definition: matrixmarket.hh:855
void mm_print_entry(const B &entry, std::size_t rowidx, std::size_t colidx, std::ostream &ostr)
Definition: matrixmarket.hh:1014
Definition: allocator.hh:9
std::tuple< std::size_t, std::size_t, std::size_t > calculateNNZ(std::size_t rows, std::size_t cols, std::size_t entries, const MMHeader &header)
Definition: matrixmarket.hh:545
bool operator<(const IndexData< T > &i1, const IndexData< T > &i2)
LessThan operator.
Definition: matrixmarket.hh:628
LineType
Definition: matrixmarket.hh:294
@ DATA
Definition: matrixmarket.hh:294
@ MM_HEADER
Definition: matrixmarket.hh:294
@ MM_ISTLSTRUCT
Definition: matrixmarket.hh:294
bool readMatrixMarketBanner(std::istream &file, MMHeader &mmHeader)
Definition: matrixmarket.hh:351
void readSparseEntries(Dune::BCRSMatrix< T, A > &matrix, std::istream &file, std::size_t entries, const MMHeader &mmHeader, const D &)
Definition: matrixmarket.hh:763
MM_TYPE
Definition: matrixmarket.hh:297
@ array_type
Definition: matrixmarket.hh:297
@ coordinate_type
Definition: matrixmarket.hh:297
@ unknown_type
Definition: matrixmarket.hh:297
std::istream & operator>>(std::istream &is, NumericWrapper< T > &num)
Definition: matrixmarket.hh:612
void skipComments(std::istream &file)
Definition: matrixmarket.hh:337
bool lineFeed(std::istream &file)
Definition: matrixmarket.hh:313
@ MM_MAX_LINE_LENGTH
Definition: matrixmarket.hh:295
MM_STRUCTURE
Definition: matrixmarket.hh:301
@ skew_symmetric
Definition: matrixmarket.hh:301
@ general
Definition: matrixmarket.hh:301
@ hermitian
Definition: matrixmarket.hh:301
@ unknown_structure
Definition: matrixmarket.hh:301
@ symmetric
Definition: matrixmarket.hh:301
MM_CTYPE
Definition: matrixmarket.hh:299
@ unknown_ctype
Definition: matrixmarket.hh:299
@ pattern
Definition: matrixmarket.hh:299
@ complex_type
Definition: matrixmarket.hh:299
@ double_type
Definition: matrixmarket.hh:299
@ integer_type
Definition: matrixmarket.hh:299
std::enable_if_t<!is_complex< T >::value, T > conj(const T &r)
Definition: matrixmarket.hh:731
A sparse block matrix with compressed row storage.
Definition: bcrsmatrix.hh:464
Iterator begin()
Get iterator to first row.
Definition: bcrsmatrix.hh:673
Iterator end()
Get iterator to one beyond last row.
Definition: bcrsmatrix.hh:679
CreateIterator createend()
get create iterator pointing to one after the last block
Definition: bcrsmatrix.hh:1101
size_type M() const
number of columns (counted in blocks)
Definition: bcrsmatrix.hh:1976
CreateIterator createbegin()
get initial create iterator
Definition: bcrsmatrix.hh:1095
size_type N() const
number of rows (counted in blocks)
Definition: bcrsmatrix.hh:1970
void setBuildMode(BuildMode bm)
Sets the build mode of the matrix.
Definition: bcrsmatrix.hh:831
void setSize(size_type rows, size_type columns, size_type nnz=0)
Set the size of the matrix.
Definition: bcrsmatrix.hh:859
A vector of blocks with memory management.
Definition: bvector.hh:393
void resize(size_type size)
Resize the vector.
Definition: bvector.hh:501
typename Imp::BlockTraits< B >::field_type field_type
export the type representing the field
Definition: bvector.hh:399
A generic dynamic dense matrix.
Definition: matrix.hh:559
Helper metaprogram to get the matrix market string representation of the numeric type.
Definition: matrixmarket.hh:74
@ is_numeric
Whether T is a supported numeric type.
Definition: matrixmarket.hh:79
static std::string str()
Definition: matrixmarket.hh:93
static std::string str()
Definition: matrixmarket.hh:109
static std::string str()
Definition: matrixmarket.hh:125
static std::string str()
Definition: matrixmarket.hh:141
static std::string str()
Definition: matrixmarket.hh:157
Meta program to write the correct Matrix Market header.
Definition: matrixmarket.hh:172
static void print(std::ostream &os)
Definition: matrixmarket.hh:177
static void print(std::ostream &os)
Definition: matrixmarket.hh:187
static void print(std::ostream &os)
Definition: matrixmarket.hh:197
static void print(std::ostream &os)
Definition: matrixmarket.hh:207
Metaprogram for writing the ISTL block structure header.
Definition: matrixmarket.hh:223
static void print(std::ostream &os, const M &)
Definition: matrixmarket.hh:231
BlockVector< T, A > M
Definition: matrixmarket.hh:228
BlockVector< FieldVector< T, i >, A > M
Definition: matrixmarket.hh:241
static void print(std::ostream &os, const M &)
Definition: matrixmarket.hh:243
BCRSMatrix< T, A > M
Definition: matrixmarket.hh:253
static void print(std::ostream &os, const M &)
Definition: matrixmarket.hh:256
BCRSMatrix< FieldMatrix< T, i, j >, A > M
Definition: matrixmarket.hh:266
static void print(std::ostream &os, const M &)
Definition: matrixmarket.hh:268
static void print(std::ostream &os, const M &m)
Definition: matrixmarket.hh:281
FieldMatrix< T, i, j > M
Definition: matrixmarket.hh:279
static void print(std::ostream &os, const M &m)
Definition: matrixmarket.hh:290
FieldVector< T, i > M
Definition: matrixmarket.hh:288
Definition: matrixmarket.hh:304
MM_STRUCTURE structure
Definition: matrixmarket.hh:310
MM_TYPE type
Definition: matrixmarket.hh:308
MMHeader()
Definition: matrixmarket.hh:305
MM_CTYPE ctype
Definition: matrixmarket.hh:309
Definition: matrixmarket.hh:576
std::size_t index
Definition: matrixmarket.hh:577
a wrapper class of numeric values.
Definition: matrixmarket.hh:593
T number
Definition: matrixmarket.hh:594
Utility class for marking the pattern type of the MatrixMarket matrices.
Definition: matrixmarket.hh:605
Functor to the data values of the matrix.
Definition: matrixmarket.hh:675
void operator()(const std::vector< std::set< IndexData< D > > > &rows, BCRSMatrix< T > &matrix)
Sets the matrix values.
Definition: matrixmarket.hh:682
void operator()(const std::vector< std::set< IndexData< D > > > &rows, BCRSMatrix< FieldMatrix< T, brows, bcols > > &matrix)
Sets the matrix values.
Definition: matrixmarket.hh:700
void operator()(const std::vector< std::set< IndexData< PatternDummy > > > &rows, M &matrix)
Definition: matrixmarket.hh:721
Definition: matrixmarket.hh:726
Definition: matrixmarket.hh:742
Definition: matrixmarket.hh:852
Definition: matrixutils.hh:25
Test whether a type is an ISTL Matrix.
Definition: matrixutils.hh:502
A class setting up standard communication for a two-valued attribute set with owner/overlap/copy sema...
Definition: owneroverlapcopy.hh:172
const ParallelIndexSet & indexSet() const
Get the underlying parallel index set.
Definition: owneroverlapcopy.hh:460
const CollectiveCommunication< MPI_Comm > & communicator() const
Definition: owneroverlapcopy.hh:297
const RemoteIndices & remoteIndices() const
Get the underlying remote indices.
Definition: owneroverlapcopy.hh:469
Dune::ParallelIndexSet< GlobalIdType, LI, 512 > ParallelIndexSet
The type of the parallel index set.
Definition: owneroverlapcopy.hh:447