//--------------------------------------------------------------------------
int Epetra_FEVbrMatrix::SetupForNonlocalSubmits(int BlockRow,
int NumBlockEntries,
int * BlockIndices,
bool indicesAreLocal,
Epetra_CombineMode SubmitMode)
{
(void)indicesAreLocal;
if (ignoreNonLocalEntries_) {
curRowOffset_ = 0;
return(0);
}
int insertPoint = -1;
//find offset of this row in our list of nonlocal rows
int rowoffset = Epetra_Util_binary_search(BlockRow, nonlocalBlockRows_,
numNonlocalBlockRows_, insertPoint);
//if this row is not already present, insert it
if (rowoffset < 0) {
EPETRA_CHK_ERR( InsertNonlocalRow(BlockRow, insertPoint, NumBlockEntries) );
rowoffset = insertPoint;
}
//now insert each incoming block-column-index in this list of column-indices,
//maintaining sortedness.
for(int i=0; i<NumBlockEntries; ++i) {
int col = BlockIndices[i];
int coloffset = Epetra_Util_binary_search(col, nonlocalBlockCols_[rowoffset],
nonlocalBlockRowLengths_[rowoffset],
insertPoint);
if (coloffset < 0) {
int tmp1 = nonlocalBlockRowLengths_[rowoffset];
int tmp2 = nonlocalBlockRowAllocLengths_[rowoffset];
EPETRA_CHK_ERR( Epetra_Util_insert(col, insertPoint,
nonlocalBlockCols_[rowoffset],
nonlocalBlockRowLengths_[rowoffset],
nonlocalBlockRowAllocLengths_[rowoffset]));
EPETRA_CHK_ERR( Epetra_Util_insert((Epetra_SerialDenseMatrix*)NULL,
insertPoint,
nonlocalCoefs_[rowoffset],
tmp1, tmp2) );
}
}
curRowOffset_ = rowoffset;
curColOffset_ = 0;
curNumCols_ = NumBlockEntries;
curCols_ = new int[NumBlockEntries];
for(int j=0; j<NumBlockEntries; ++j) {
curCols_[j] = BlockIndices[j];
}
curMode_ = SubmitMode;
return(0);
}
int Epetra_FECrsMatrix::InputNonlocalGlobalValues(int_type row,
int numCols, const int_type* cols,
const double* values,
int mode)
{
if(!RowMap().template GlobalIndicesIsType<int_type>())
throw ReportError("Epetra_FECrsMatrix::InputNonlocalGlobalValues mismatch between argument types (int/long long) and map type.", -1);
// if we already have a nonlocal matrix object, this is easier...
if (useNonlocalMatrix_) {
int err, returncode = 0;
double* valuesptr = (double*)values;
switch(mode) {
case Epetra_FECrsMatrix::SUMINTO:
err = nonlocalMatrix_->SumIntoGlobalValues(row, numCols,
valuesptr, (int_type*)cols);
if (err<0) return(err);
if (err>0) returncode = err;
break;
case Epetra_FECrsMatrix::REPLACE:
err = nonlocalMatrix_->ReplaceGlobalValues(row, numCols,
valuesptr, (int_type*)cols);
if (err<0) return(err);
if (err>0) returncode = err;
break;
case Epetra_FECrsMatrix::INSERT:
err = nonlocalMatrix_->InsertGlobalValues(row, numCols,
valuesptr, (int_type*)cols);
if (err<0) return(err);
if (err>0) returncode = err;
break;
default:
std::cerr << "Epetra_FECrsMatrix: internal error, bad input mode."<< std::endl;
return(-1);
}
return (returncode);
}
int ierr1 = 0, ierr2 = 0;
#ifdef EPETRA_HAVE_OMP
#ifdef EPETRA_HAVE_OMP_NONASSOCIATIVE
#pragma omp critical
#endif
#endif
{
std::vector<int_type>& nonlocalRows_var = nonlocalRows<int_type>();
//find offset of this row in our list of nonlocal rows.
typename std::vector<int_type>::iterator it =
std::lower_bound(nonlocalRows_var.begin(), nonlocalRows_var.end(), row);
int rowoffset = (int) (it - nonlocalRows_var.begin());
if (it == nonlocalRows_var.end() || *it != row) {
ierr1 = InsertNonlocalRow(row, it);
}
for(int i=0; i<numCols; ++i) {
ierr2 = InputNonlocalValue(rowoffset, cols[i], values[i], mode);
}
}
EPETRA_CHK_ERR(ierr1);
EPETRA_CHK_ERR(ierr2);
return(0);
}
