/*
* Render the whole screen by querying the model.
*/
static void
screen_render(Screen *s)
{
/* determine the visible set of rows using key */
RowIterator iter = RowMapLowerBound(rowmap(s), key(s));
RowIterator end = RowMapEnd(rowmap(s));
/* reposition the cursor to the origin */
int i = 0;
int ctr = 0;
move(ctr, 0);
/* display the header row in reverse video at the top of screen */
attron(A_REVERSE);
render_row(s, &s->model->header, '|');
attroff(A_REVERSE);
ctr++;
/* render visible set */
for (; iter != end && ctr < lines(s); iter++, ++ctr)
{
render_row(s, iter, ' ');
}
/* blank out any remaining rows below the last row */
for (i = ctr; i < lines(s); ++i) {
printw("\n");
clrtoeol();
}
}
static void
screen_scroll_down(Screen *s)
{
RowIterator iter = RowMapLowerBound(rowmap(s), key(s));
if (iter != RowMapEnd(rowmap(s)))
{
iter++;
if (iter != RowMapEnd(rowmap(s)))
set_key(s, RowGetKey(iter));
}
}
/*
* Scroll up/down by figuring out the pred/succ key in the model
*/
static void
screen_scroll_up(Screen *s)
{
RowIterator iter = RowMapLowerBound(rowmap(s), key(s));
if (iter != RowMapBegin(rowmap(s))) {
iter--;
set_key(s, RowGetKey(iter));
} else {
clear_key(s);
}
}
Epetra_CrsMatrix* create_epetra_test_matrix_1(int numProcs,
int localProc,
bool verbose)
{
if (verbose) {
std::cout << " creating Epetra_CrsMatrix with un-even distribution..."
<< std::endl;
}
//create an Epetra_CrsMatrix with rows spread un-evenly over
//processors.
#ifdef HAVE_MPI
Epetra_MpiComm comm(MPI_COMM_WORLD);
#else
Epetra_SerialComm comm;
#endif
int local_num_rows = 360;
int nnz_per_row = local_num_rows/4+1;
int global_num_rows = numProcs*local_num_rows;
int mid_proc = numProcs/2;
bool num_procs_even = numProcs%2==0 ? true : false;
int adjustment = local_num_rows/2;
//adjust local_num_rows so that it's not equal on all procs.
if (localProc < mid_proc) {
local_num_rows -= adjustment;
}
else {
local_num_rows += adjustment;
}
//if numProcs is not an even number, undo the local_num_rows adjustment
//on one proc so that the total will still be correct.
if (localProc == numProcs-1) {
if (num_procs_even == false) {
local_num_rows -= adjustment;
}
}
//now we're ready to create a row-map.
Epetra_Map rowmap(global_num_rows, local_num_rows, 0, comm);
//create a matrix
Epetra_CrsMatrix* input_matrix =
new Epetra_CrsMatrix(Copy, rowmap, nnz_per_row);
int err = ispatest::fill_matrix(*input_matrix, nnz_per_row, verbose);
if (err != 0) {
delete input_matrix;
return(0);
}
return(input_matrix);
}
EpetraRowMatrix<TpetraMatrixType>::EpetraRowMatrix(
const Teuchos::RCP<TpetraMatrixType> &mat, const Epetra_Comm &comm
)
: Epetra_BasicRowMatrix(comm),
tpetra_matrix_(mat)
{
typedef typename TpetraMatrixType::global_ordinal_type GO;
GO globalNumRows = tpetra_matrix_->getRowMap()->getGlobalNumElements();
GO globalNumCols = tpetra_matrix_->getColMap()->getGlobalNumElements();
Teuchos::ArrayView<const GO> row_elem_list = tpetra_matrix_->getRowMap()->getNodeElementList();
Teuchos::ArrayView<const GO> col_elem_list = tpetra_matrix_->getColMap()->getNodeElementList();
Epetra_Map rowmap(globalNumRows, row_elem_list.size(), row_elem_list.getRawPtr(), 0, comm);
Epetra_Map colmap(globalNumCols, col_elem_list.size(), col_elem_list.getRawPtr(), 0, comm);
SetMaps(rowmap, colmap);
}
int rectangular(const Epetra_Comm& Comm, bool verbose)
{
int mypid = Comm.MyPID();
int numlocalrows = 3;
Epetra_Map rowmap((long long) -1, numlocalrows, 0, Comm);
long long numglobalrows = numlocalrows*Comm.NumProc();
long long numcols = 2*numglobalrows;
Epetra_FECrsGraph fegraph(Copy, rowmap, numcols);
long long* cols = new long long[numcols];
for(int j=0; j<numcols; ++j) cols[j] = j;
Epetra_Map domainmap((long long) -1, numcols, 0, Comm);
long long firstlocalrow = numlocalrows*mypid;
long long lastlocalrow = numlocalrows*(mypid+1)-1;
for(long long i=0; i<numglobalrows; ++i) {
//if i is a local row, then skip it. We want each processor to only
//load rows that belong on other processors.
if (i >= firstlocalrow && i <= lastlocalrow) continue;
EPETRA_CHK_ERR( fegraph.InsertGlobalIndices(1, &i, numcols, &(cols[0])) );
}
EPETRA_CHK_ERR( fegraph.GlobalAssemble(domainmap, rowmap) );
if (verbose) {
std::cout << "********************** fegraph **********************" << std::endl;
std::cout << fegraph << std::endl;
}
delete [] cols;
return(0);
}
Epetra_CrsMatrix*
read_matrix_mm(const std::string& mm_file,
const Epetra_Comm& comm)
{
int my_proc = comm.MyPID();
long long num_global_rows = 0;
int nnz_per_row = 0;
std::ifstream* infile = NULL;
infile = new std::ifstream(mm_file.c_str());
if (infile == NULL || !*infile) {
throw std::runtime_error("Failed to open file "+mm_file);
}
std::ifstream& in = *infile;
//first skip over the file header, which has
//lines beginning with '%'.
std::string line;
do {
getline(in, line);
} while(line[0] == '%');
//now get the matrix dimensions.
int numrows, numcols, nnz;
std::istringstream isstr(line);
isstr >> numrows >> numcols >> nnz;
//make sure we successfully read the three ints from that line.
if (isstr.fail()) {
throw std::runtime_error("Failed to parse matrix-market header.");
}
if (my_proc == 0) {
num_global_rows = numrows;
nnz_per_row = nnz/numrows;
}
comm.Broadcast(&num_global_rows, 1, 0);
comm.Broadcast(&nnz_per_row, 1, 0);
const int indexBase = 0;
Epetra_Map rowmap(num_global_rows, indexBase, comm);
Epetra_CrsMatrix* A = new Epetra_CrsMatrix(Copy, rowmap, nnz_per_row);
Teuchos::Array<long long> col;
Teuchos::Array<double> coef;
int irow=0, icol=0;
int g_row=-1, last_row=-1;
double val=0;
while(!in.eof()) {
getline(in, line);
std::istringstream isstr(line);
isstr >> irow >> icol >> val;
if (isstr.fail()) continue;
if (!rowmap.MyGID(irow-1)) continue;
g_row = irow-1;
if (g_row != last_row) {
if (col.size() > 0) {
A->InsertGlobalValues(last_row, col.size(), &coef[0], &col[0] );
col.clear();
coef.clear();
}
last_row = g_row;
}
col.push_back(icol-1);
coef.push_back(val);
}
if (col.size() > 0) {
A->InsertGlobalValues(g_row, col.size(), &coef[0], &col[0]);
}
A->FillComplete();
return A;
}
Teuchos::RCP<Epetra_CrsGraph>
create_epetra_graph(int numProcs, int localProc)
{
if (localProc == 0) {
std::cout << " creating Epetra_CrsGraph with un-even distribution..."
<< std::endl;
}
//create an Epetra_CrsGraph with rows spread un-evenly over
//processors.
Epetra_MpiComm comm(MPI_COMM_WORLD);
int local_num_rows = 800;
int nnz_per_row = local_num_rows/4+1;
int global_num_rows = numProcs*local_num_rows;
int mid_proc = numProcs/2;
bool num_procs_even = numProcs%2==0 ? true : false;
int adjustment = local_num_rows/2;
//adjust local_num_rows so that it's not equal on all procs.
if (localProc < mid_proc) {
local_num_rows -= adjustment;
}
else {
local_num_rows += adjustment;
}
//if numProcs is not an even number, undo the local_num_rows adjustment
//on one proc so that the total will still be correct.
if (localProc == numProcs-1) {
if (num_procs_even == false) {
local_num_rows -= adjustment;
}
}
//now we're ready to create a row-map.
Epetra_Map rowmap(global_num_rows, local_num_rows, 0, comm);
//create a graph
Teuchos::RCP<Epetra_CrsGraph> graph =
Teuchos::rcp(new Epetra_CrsGraph(Copy, rowmap, nnz_per_row));
std::vector<int> indices(nnz_per_row);
std::vector<double> coefs(nnz_per_row);
int err = 0;
for(int i=0; i<local_num_rows; ++i) {
int global_row = rowmap.GID(i);
int first_col = global_row - nnz_per_row/2;
if (first_col < 0) {
first_col = 0;
}
else if (first_col > (global_num_rows - nnz_per_row)) {
first_col = global_num_rows - nnz_per_row;
}
for(int j=0; j<nnz_per_row; ++j) {
indices[j] = first_col + j;
coefs[j] = 1.0;
}
err = graph->InsertGlobalIndices(global_row, nnz_per_row,
&indices[0]);
if (err < 0) {
throw Isorropia::Exception("create_epetra_graph: error inserting indices in graph");
}
}
err = graph->FillComplete();
if (err != 0) {
throw Isorropia::Exception("create_epetra_graph: error in graph.FillComplete()");
}
return(graph);
}
Epetra_LinearProblem* create_epetra_problem(int numProcs,
int localProc,
int local_n)
{
if (localProc == 0) {
std::cout << " creating Epetra_CrsMatrix with un-even distribution..."
<< std::endl;
}
//create an Epetra_CrsMatrix with rows spread un-evenly over
//processors.
Epetra_MpiComm comm(MPI_COMM_WORLD);
int global_num_rows = numProcs*local_n;
int mid_proc = numProcs/2;
bool num_procs_even = numProcs%2==0 ? true : false;
int adjustment = local_n/2;
//adjust local_n so that it's not equal on all procs.
if (localProc < mid_proc) {
local_n -= adjustment;
}
else {
local_n += adjustment;
}
//if numProcs is not an even number, undo the local_n adjustment
//on one proc so that the total will still be correct.
if (localProc == numProcs-1) {
if (num_procs_even == false) {
local_n -= adjustment;
}
}
//now we're ready to create a row-map.
Epetra_Map rowmap(global_num_rows, local_n, 0, comm);
//create a matrix
int nnz_per_row = 9;
Epetra_CrsMatrix* matrix =
new Epetra_CrsMatrix(Copy, rowmap, nnz_per_row);
// Add rows one-at-a-time
double negOne = -1.0;
double posTwo = 4.0;
for (int i=0; i<local_n; i++) {
int GlobalRow = matrix->GRID(i);
int RowLess1 = GlobalRow - 1;
int RowPlus1 = GlobalRow + 1;
int RowLess2 = GlobalRow - 2;
int RowPlus2 = GlobalRow + 2;
int RowLess3 = GlobalRow - 3;
int RowPlus3 = GlobalRow + 3;
int RowLess4 = GlobalRow - 4;
int RowPlus4 = GlobalRow + 4;
if (RowLess4>=0) {
matrix->InsertGlobalValues(GlobalRow, 1, &negOne, &RowLess4);
}
if (RowLess3>=0) {
matrix->InsertGlobalValues(GlobalRow, 1, &negOne, &RowLess3);
}
if (RowLess2>=0) {
matrix->InsertGlobalValues(GlobalRow, 1, &negOne, &RowLess2);
}
if (RowLess1>=0) {
matrix->InsertGlobalValues(GlobalRow, 1, &negOne, &RowLess1);
}
if (RowPlus1<global_num_rows) {
matrix->InsertGlobalValues(GlobalRow, 1, &negOne, &RowPlus1);
}
if (RowPlus2<global_num_rows) {
matrix->InsertGlobalValues(GlobalRow, 1, &negOne, &RowPlus2);
}
if (RowPlus3<global_num_rows) {
matrix->InsertGlobalValues(GlobalRow, 1, &negOne, &RowPlus3);
}
if (RowPlus4<global_num_rows) {
matrix->InsertGlobalValues(GlobalRow, 1, &negOne, &RowPlus4);
}
matrix->InsertGlobalValues(GlobalRow, 1, &posTwo, &GlobalRow);
}
int err = matrix->FillComplete();
if (err != 0) {
throw Isorropia::Exception("create_epetra_matrix: error in matrix.FillComplete()");
}
Epetra_Vector* x = new Epetra_Vector(rowmap);
Epetra_Vector* b = new Epetra_Vector(rowmap);
return(new Epetra_LinearProblem(matrix, x, b));
}
