src/CPPAdapter/SystemMatrixAdapter.cpp


/*******************************************************
*
* Copyright (c) 2003-2008 by University of Queensland
* Earth Systems Science Computational Center (ESSCC)
* http://www.uq.edu.au/esscc
*
* Primary Business: Queensland, Australia
* Licensed under the Open Software License version 3.0
* http://www.opensource.org/licenses/osl-3.0.php
*
*******************************************************/


#ifdef PASO_MPI
#include <mpi.h>
#endif
#include "SystemMatrixAdapter.h" 

using namespace std;

namespace finley {

struct null_deleter
{
   void operator()(void const *ptr) const
      {
      }
};


SystemMatrixAdapter::SystemMatrixAdapter()
{
   throw FinleyAdapterException("Error - Illegal to generate default SystemMatrixAdapter.");
}

SystemMatrixAdapter::SystemMatrixAdapter(Paso_SystemMatrix* system_matrix,
                                         const int row_blocksize,
                                         const escript::FunctionSpace& row_functionspace,
                                         const int column_blocksize,
                                         const escript::FunctionSpace& column_functionspace):
AbstractSystemMatrix(row_blocksize,row_functionspace,column_blocksize,column_functionspace)
{
   m_system_matrix.reset(system_matrix,null_deleter());
}

SystemMatrixAdapter::~SystemMatrixAdapter()
{ 
   if (m_system_matrix.unique()) {
      Paso_SystemMatrix* mat=m_system_matrix.get();
      Paso_SystemMatrix_free(mat);
   }
}

Paso_SystemMatrix* SystemMatrixAdapter::getPaso_SystemMatrix() const 
{
   return m_system_matrix.get();
}

void SystemMatrixAdapter::ypAx(escript::Data& y,escript::Data& x) const 
{
   Paso_SystemMatrix* mat=getPaso_SystemMatrix();

   if ( x.getDataPointSize()  != getColumnBlockSize()) {
      throw FinleyAdapterException("matrix vector product : column block size does not match the number of components in input.");
   } else if (y.getDataPointSize() != getRowBlockSize()) {
      throw FinleyAdapterException("matrix vector product : row block size does not match the number of components in output.");
   } else if ( x.getFunctionSpace()  != getColumnFunctionSpace()) {
      throw FinleyAdapterException("matrix vector product : column function space and function space of input don't match.");
   } else if (y.getFunctionSpace() != getRowFunctionSpace()) {
      throw FinleyAdapterException("matrix vector product : row function space and function space of output don't match.");
   }
   x.expand();
   y.expand();
   double* x_dp=x.getSampleData(0);
   double* y_dp=y.getSampleData(0);
   Paso_SystemMatrix_MatrixVector(1., mat,x_dp, 1.,y_dp);
   checkPasoError();
}

int SystemMatrixAdapter::mapOptionToPaso(const int option)  {
   switch (option) {
       case  ESCRIPT_DEFAULT:
          return PASO_DEFAULT;
       case  ESCRIPT_DIRECT:
          return PASO_DIRECT;
       case  ESCRIPT_CHOLEVSKY:
          return PASO_CHOLEVSKY;
       case  ESCRIPT_PCG:
          return PASO_PCG;
       case  ESCRIPT_CR:
          return PASO_CR;
       case  ESCRIPT_CGS:
          return PASO_CGS;
       case  ESCRIPT_BICGSTAB:
          return PASO_BICGSTAB;
       case  ESCRIPT_SSOR:
          return PASO_SSOR;
       case  ESCRIPT_ILU0:
          return PASO_ILU0;
       case  ESCRIPT_ILUT:
          return PASO_ILUT;
       case  ESCRIPT_JACOBI:
          return PASO_JACOBI;
       case  ESCRIPT_GMRES:
          return PASO_GMRES;
       case  ESCRIPT_PRES20:
          return PASO_PRES20;
       case  ESCRIPT_NO_REORDERING:
          return PASO_NO_REORDERING;
       case  ESCRIPT_MINIMUM_FILL_IN:
          return PASO_MINIMUM_FILL_IN;
       case  ESCRIPT_NESTED_DISSECTION:
          return PASO_NESTED_DISSECTION;
       case  ESCRIPT_SCSL:
          return PASO_SCSL;
       case  ESCRIPT_MKL:
          return PASO_MKL;
       case  ESCRIPT_UMFPACK:
          return PASO_UMFPACK;
       case  ESCRIPT_ITERATIVE:
          return PASO_ITERATIVE;
       case  ESCRIPT_PASO:
          return PASO_PASO;
       case  ESCRIPT_LUMPING:
          return PASO_LUMPING;
       case  ESCRIPT_AMG:
          return PASO_AMG;
       case  ESCRIPT_RILU:
          return PASO_RILU;
       case  ESCRIPT_TRILINOS:
          return PASO_TRILINOS;
       case  ESCRIPT_NONLINEAR_GMRES:
          return PASO_NONLINEAR_GMRES;
       case  ESCRIPT_TFQMR:
          return PASO_TFQMR;
       case  ESCRIPT_MINRES:
          return PASO_MINRES;
       case  ESCRIPT_GS:
          return PASO_GS;
       default:
           stringstream temp;
           temp << "Error - Cannot map option value "<< option << " onto Paso";
           throw FinleyAdapterException(temp.str());
    }
}

void finley::SystemMatrixAdapter::Print_Matrix_Info(const bool full=false) const
{
   Paso_SystemMatrix* mat=m_system_matrix.get();
   int first_row_index  = mat->row_distribution->first_component[mat->mpi_info->rank];
   int last_row_index   = mat->row_distribution->first_component[mat->mpi_info->rank+1]-1;
   int first_col_index  = mat->col_distribution->first_component[mat->mpi_info->rank];
   int last_col_index   = mat->col_distribution->first_component[mat->mpi_info->rank+1]-1;

   fprintf(stdout, "Print_Matrix_Info running on CPU %d of %d\n", mat->mpi_info->rank, mat->mpi_info->size);

   switch (mat->type) {
   case MATRIX_FORMAT_DEFAULT:      fprintf(stdout, "\tMatrix type MATRIX_FORMAT_DEFAULT\n"); break;
   case MATRIX_FORMAT_CSC:      fprintf(stdout, "\tMatrix type MATRIX_FORMAT_CSC\n"); break;
   case MATRIX_FORMAT_SYM:      fprintf(stdout, "\tMatrix type MATRIX_FORMAT_SYM\n"); break;
   case MATRIX_FORMAT_BLK1:     fprintf(stdout, "\tMatrix type MATRIX_FORMAT_BLK1\n"); break;
   case MATRIX_FORMAT_OFFSET1:      fprintf(stdout, "\tMatrix type MATRIX_FORMAT_OFFSET1\n"); break;
   case MATRIX_FORMAT_TRILINOS_CRS: fprintf(stdout, "\tMatrix type MATRIX_FORMAT_TRILINOS_CRS\n"); break;
   default:             fprintf(stdout, "\tMatrix type unknown\n"); break;
   }

   fprintf(stdout, "\trow indices run from %d to %d\n", first_row_index, last_row_index);
   fprintf(stdout, "\tcol indices run from %d to %d\n", first_col_index, last_col_index);
   fprintf(stdout, "\tmainBlock numRows %d\n", mat->mainBlock->numRows);
   fprintf(stdout, "\tmainBlock numCols %d\n", mat->mainBlock->numCols);
   fprintf(stdout, "\tmainBlock pattern numOutput %d\n", mat->mainBlock->pattern->numOutput);
   fprintf(stdout, "\tcol_coupleBlock numRows %d\n", mat->col_coupleBlock->numRows);
   fprintf(stdout, "\tcol_coupleBlock numCols %d\n", mat->col_coupleBlock->numCols);
   fprintf(stdout, "\tcol_coupleBlock pattern numOutput %d\n", mat->col_coupleBlock->pattern->numOutput);
   fprintf(stdout, "\trow_coupleBlock numRows %d\n", mat->row_coupleBlock->numRows);
   fprintf(stdout, "\trow_coupleBlock numCols %d\n", mat->row_coupleBlock->numCols);
   fprintf(stdout, "\trow_coupleBlock pattern numOutput %d\n", mat->row_coupleBlock->pattern->numOutput);
   fprintf(stdout, "\trow_block_size %d\n", mat->row_block_size);
   fprintf(stdout, "\tcol_block_size %d\n", mat->col_block_size);
   fprintf(stdout, "\tblock_size %d\n", mat->block_size);
   fprintf(stdout, "\tlogical_row_block_size %d\n", mat->logical_row_block_size);
   fprintf(stdout, "\tlogical_col_block_size %d\n", mat->logical_col_block_size);
   fprintf(stdout, "\tlogical_block_size %d\n", mat->logical_block_size);

}

void SystemMatrixAdapter::setToSolution(escript::Data& out,escript::Data& in, const boost::python::dict& options) const
{
   Paso_SystemMatrix* mat=getPaso_SystemMatrix();
   Paso_Options paso_options;
   dictToPasoOptions(&paso_options,options);
   if ( out.getDataPointSize()  != getColumnBlockSize()) {
      throw FinleyAdapterException("solve : column block size does not match the number of components of solution.");
   } else if ( in.getDataPointSize() != getRowBlockSize()) {
      throw FinleyAdapterException("solve : row block size does not match the number of components of  right hand side.");
   } else if ( out.getFunctionSpace()  != getColumnFunctionSpace()) {
      throw FinleyAdapterException("solve : column function space and function space of solution don't match.");
   } else if (in.getFunctionSpace() != getRowFunctionSpace()) {
      throw FinleyAdapterException("solve : row function space and function space of right hand side don't match.");
   }
   out.expand();
   in.expand();
   double* out_dp=out.getSampleData(0);
   double* in_dp=in.getSampleData(0);
   Paso_solve(mat,out_dp,in_dp,&paso_options);
   checkPasoError();
}

void SystemMatrixAdapter::nullifyRowsAndCols(escript::Data& row_q,escript::Data& col_q, const double mdv) const
{
   Paso_SystemMatrix* mat = getPaso_SystemMatrix();
   if ( col_q.getDataPointSize()  != getColumnBlockSize()) {
      throw FinleyAdapterException("nullifyRowsAndCols : column block size does not match the number of components of column mask.");
   } else if ( row_q.getDataPointSize() != getRowBlockSize()) {
      throw FinleyAdapterException("nullifyRowsAndCols : row block size does not match the number of components of row mask.");
   } else if ( col_q.getFunctionSpace()  != getColumnFunctionSpace()) {
      throw FinleyAdapterException("nullifyRowsAndCols : column function space and function space of column mask don't match.");
   } else if (row_q.getFunctionSpace() != getRowFunctionSpace()) {
      throw FinleyAdapterException("nullifyRowsAndCols : row function space and function space of row mask don't match.");
   }
   row_q.expand();
   col_q.expand();
   double* row_q_dp=row_q.getSampleData(0);
   double* col_q_dp=col_q.getSampleData(0);
   Paso_SystemMatrix_nullifyRowsAndCols(mat,row_q_dp,col_q_dp, mdv);
   checkPasoError();
}

void SystemMatrixAdapter::saveMM(const std::string& fileName) const
{
   if( fileName.size() == 0 )
   {
      throw FinleyAdapterException("Null file name!");
   }

   char *fName = TMPMEMALLOC(fileName.size()+1,char);
    
   strcpy(fName,fileName.c_str());
   Paso_SystemMatrix* mat = getPaso_SystemMatrix();
   Paso_SystemMatrix_saveMM(mat,fName);
   checkPasoError();
   TMPMEMFREE(fName);

}

void SystemMatrixAdapter::saveHB(const std::string& fileName) const
{
   if( fileName.size() == 0 )
   {
      throw FinleyAdapterException("Null file name!");
   }

   char *fName = TMPMEMALLOC(fileName.size()+1,char);

   strcpy(fName,fileName.c_str());
   Paso_SystemMatrix* mat = getPaso_SystemMatrix();
   Paso_SystemMatrix_saveHB(mat,fName);
   checkPasoError();
   TMPMEMFREE(fName);

}

void SystemMatrixAdapter::resetValues() const
{
   Paso_SystemMatrix* mat = getPaso_SystemMatrix();
   Paso_SystemMatrix_setValues(mat,0.);
   Paso_solve_free(mat);
   checkPasoError();
}

void SystemMatrixAdapter::dictToPasoOptions(Paso_Options* paso_options, const boost::python::dict& options) 
{
   Paso_Options_setDefaults(paso_options);
#define EXTRACT(__key__,__val__,__type__) if ( options.has_key(__key__)) paso_options->__val__=boost::python::extract<__type__>(options.get(__key__))
#define EXTRACT_OPTION(__key__,__val__,__type__) if ( options.has_key(__key__)) paso_options->__val__=mapOptionToPaso(boost::python::extract<__type__>(options.get(__key__)))
   EXTRACT("verbose",verbose,int);
   EXTRACT_OPTION("reordering",reordering,int);
   EXTRACT(ESCRIPT_TOLERANCE_KEY,tolerance,double);
   EXTRACT_OPTION(ESCRIPT_METHOD_KEY,method,int);
   EXTRACT(ESCRIPT_SYMMETRY_KEY,symmetric,int);
   EXTRACT_OPTION(ESCRIPT_PACKAGE_KEY,package,int);
   EXTRACT_OPTION("preconditioner",preconditioner,int);
   EXTRACT("iter_max",iter_max,int);
   EXTRACT("drop_tolerance",drop_tolerance,double);
   EXTRACT("drop_storage",drop_storage,double);
   EXTRACT("truncation",truncation,int);
   EXTRACT("restart",restart,int);
   EXTRACT("sweeps",sweeps,int);
#undef EXTRACT
#undef EXTRACT_OPTION
}
 

}  // end of namespace
1
2	/*******************************************************
3	*
4	* Copyright (c) 2003-2008 by University of Queensland
5	* Earth Systems Science Computational Center (ESSCC)
6	* http://www.uq.edu.au/esscc
7	*
8	* Primary Business: Queensland, Australia
9	* Licensed under the Open Software License version 3.0
10	* http://www.opensource.org/licenses/osl-3.0.php
11	*
12	*******************************************************/
13
14
15	#ifdef PASO_MPI
16	#include <mpi.h>
17	#endif
18	#include "SystemMatrixAdapter.h"
19
20	using namespace std;
21
22	namespace finley {
23
24	struct null_deleter
25	{
26	void operator()(void const *ptr) const
27	{
28	}
29	};
30
31
32	SystemMatrixAdapter::SystemMatrixAdapter()
33	{
34	throw FinleyAdapterException("Error - Illegal to generate default SystemMatrixAdapter.");
35	}
36
37	SystemMatrixAdapter::SystemMatrixAdapter(Paso_SystemMatrix* system_matrix,
38	const int row_blocksize,
39	const escript::FunctionSpace& row_functionspace,
40	const int column_blocksize,
41	const escript::FunctionSpace& column_functionspace):
42	AbstractSystemMatrix(row_blocksize,row_functionspace,column_blocksize,column_functionspace)
43	{
44	m_system_matrix.reset(system_matrix,null_deleter());
45	}
46
47	SystemMatrixAdapter::~SystemMatrixAdapter()
48	{
49	if (m_system_matrix.unique()) {
50	Paso_SystemMatrix* mat=m_system_matrix.get();
51	Paso_SystemMatrix_free(mat);
52	}
53	}
54
55	Paso_SystemMatrix* SystemMatrixAdapter::getPaso_SystemMatrix() const
56	{
57	return m_system_matrix.get();
58	}
59
60	void SystemMatrixAdapter::ypAx(escript::Data& y,escript::Data& x) const
61	{
62	Paso_SystemMatrix* mat=getPaso_SystemMatrix();
63
64	if ( x.getDataPointSize() != getColumnBlockSize()) {
65	throw FinleyAdapterException("matrix vector product : column block size does not match the number of components in input.");
66	} else if (y.getDataPointSize() != getRowBlockSize()) {
67	throw FinleyAdapterException("matrix vector product : row block size does not match the number of components in output.");
68	} else if ( x.getFunctionSpace() != getColumnFunctionSpace()) {
69	throw FinleyAdapterException("matrix vector product : column function space and function space of input don't match.");
70	} else if (y.getFunctionSpace() != getRowFunctionSpace()) {
71	throw FinleyAdapterException("matrix vector product : row function space and function space of output don't match.");
72	}
73	x.expand();
74	y.expand();
75	double* x_dp=x.getSampleData(0);
76	double* y_dp=y.getSampleData(0);
77	Paso_SystemMatrix_MatrixVector(1., mat,x_dp, 1.,y_dp);
78	checkPasoError();
79	}
80
81	int SystemMatrixAdapter::mapOptionToPaso(const int option) {
82	switch (option) {
83	case ESCRIPT_DEFAULT:
84	return PASO_DEFAULT;
85	case ESCRIPT_DIRECT:
86	return PASO_DIRECT;
87	case ESCRIPT_CHOLEVSKY:
88	return PASO_CHOLEVSKY;
89	case ESCRIPT_PCG:
90	return PASO_PCG;
91	case ESCRIPT_CR:
92	return PASO_CR;
93	case ESCRIPT_CGS:
94	return PASO_CGS;
95	case ESCRIPT_BICGSTAB:
96	return PASO_BICGSTAB;
97	case ESCRIPT_SSOR:
98	return PASO_SSOR;
99	case ESCRIPT_ILU0:
100	return PASO_ILU0;
101	case ESCRIPT_ILUT:
102	return PASO_ILUT;
103	case ESCRIPT_JACOBI:
104	return PASO_JACOBI;
105	case ESCRIPT_GMRES:
106	return PASO_GMRES;
107	case ESCRIPT_PRES20:
108	return PASO_PRES20;
109	case ESCRIPT_NO_REORDERING:
110	return PASO_NO_REORDERING;
111	case ESCRIPT_MINIMUM_FILL_IN:
112	return PASO_MINIMUM_FILL_IN;
113	case ESCRIPT_NESTED_DISSECTION:
114	return PASO_NESTED_DISSECTION;
115	case ESCRIPT_SCSL:
116	return PASO_SCSL;
117	case ESCRIPT_MKL:
118	return PASO_MKL;
119	case ESCRIPT_UMFPACK:
120	return PASO_UMFPACK;
121	case ESCRIPT_ITERATIVE:
122	return PASO_ITERATIVE;
123	case ESCRIPT_PASO:
124	return PASO_PASO;
125	case ESCRIPT_LUMPING:
126	return PASO_LUMPING;
127	case ESCRIPT_AMG:
128	return PASO_AMG;
129	case ESCRIPT_RILU:
130	return PASO_RILU;
131	case ESCRIPT_TRILINOS:
132	return PASO_TRILINOS;
133	case ESCRIPT_NONLINEAR_GMRES:
134	return PASO_NONLINEAR_GMRES;
135	case ESCRIPT_TFQMR:
136	return PASO_TFQMR;
137	case ESCRIPT_MINRES:
138	return PASO_MINRES;
139	case ESCRIPT_GS:
140	return PASO_GS;
141	default:
142	stringstream temp;
143	temp << "Error - Cannot map option value "<< option << " onto Paso";
144	throw FinleyAdapterException(temp.str());
145	}
146	}
147
148	void finley::SystemMatrixAdapter::Print_Matrix_Info(const bool full=false) const
149	{
150	Paso_SystemMatrix* mat=m_system_matrix.get();
151	int first_row_index = mat->row_distribution->first_component[mat->mpi_info->rank];
152	int last_row_index = mat->row_distribution->first_component[mat->mpi_info->rank+1]-1;
153	int first_col_index = mat->col_distribution->first_component[mat->mpi_info->rank];
154	int last_col_index = mat->col_distribution->first_component[mat->mpi_info->rank+1]-1;
155
156	fprintf(stdout, "Print_Matrix_Info running on CPU %d of %d\n", mat->mpi_info->rank, mat->mpi_info->size);
157
158	switch (mat->type) {
159	case MATRIX_FORMAT_DEFAULT: fprintf(stdout, "\tMatrix type MATRIX_FORMAT_DEFAULT\n"); break;
160	case MATRIX_FORMAT_CSC: fprintf(stdout, "\tMatrix type MATRIX_FORMAT_CSC\n"); break;
161	case MATRIX_FORMAT_SYM: fprintf(stdout, "\tMatrix type MATRIX_FORMAT_SYM\n"); break;
162	case MATRIX_FORMAT_BLK1: fprintf(stdout, "\tMatrix type MATRIX_FORMAT_BLK1\n"); break;
163	case MATRIX_FORMAT_OFFSET1: fprintf(stdout, "\tMatrix type MATRIX_FORMAT_OFFSET1\n"); break;
164	case MATRIX_FORMAT_TRILINOS_CRS: fprintf(stdout, "\tMatrix type MATRIX_FORMAT_TRILINOS_CRS\n"); break;
165	default: fprintf(stdout, "\tMatrix type unknown\n"); break;
166	}
167
168	fprintf(stdout, "\trow indices run from %d to %d\n", first_row_index, last_row_index);
169	fprintf(stdout, "\tcol indices run from %d to %d\n", first_col_index, last_col_index);
170	fprintf(stdout, "\tmainBlock numRows %d\n", mat->mainBlock->numRows);
171	fprintf(stdout, "\tmainBlock numCols %d\n", mat->mainBlock->numCols);
172	fprintf(stdout, "\tmainBlock pattern numOutput %d\n", mat->mainBlock->pattern->numOutput);
173	fprintf(stdout, "\tcol_coupleBlock numRows %d\n", mat->col_coupleBlock->numRows);
174	fprintf(stdout, "\tcol_coupleBlock numCols %d\n", mat->col_coupleBlock->numCols);
175	fprintf(stdout, "\tcol_coupleBlock pattern numOutput %d\n", mat->col_coupleBlock->pattern->numOutput);
176	fprintf(stdout, "\trow_coupleBlock numRows %d\n", mat->row_coupleBlock->numRows);
177	fprintf(stdout, "\trow_coupleBlock numCols %d\n", mat->row_coupleBlock->numCols);
178	fprintf(stdout, "\trow_coupleBlock pattern numOutput %d\n", mat->row_coupleBlock->pattern->numOutput);
179	fprintf(stdout, "\trow_block_size %d\n", mat->row_block_size);
180	fprintf(stdout, "\tcol_block_size %d\n", mat->col_block_size);
181	fprintf(stdout, "\tblock_size %d\n", mat->block_size);
182	fprintf(stdout, "\tlogical_row_block_size %d\n", mat->logical_row_block_size);
183	fprintf(stdout, "\tlogical_col_block_size %d\n", mat->logical_col_block_size);
184	fprintf(stdout, "\tlogical_block_size %d\n", mat->logical_block_size);
185
186	}
187
188	void SystemMatrixAdapter::setToSolution(escript::Data& out,escript::Data& in, const boost::python::dict& options) const
189	{
190	Paso_SystemMatrix* mat=getPaso_SystemMatrix();
191	Paso_Options paso_options;
192	dictToPasoOptions(&paso_options,options);
193	if ( out.getDataPointSize() != getColumnBlockSize()) {
194	throw FinleyAdapterException("solve : column block size does not match the number of components of solution.");
195	} else if ( in.getDataPointSize() != getRowBlockSize()) {
196	throw FinleyAdapterException("solve : row block size does not match the number of components of right hand side.");
197	} else if ( out.getFunctionSpace() != getColumnFunctionSpace()) {
198	throw FinleyAdapterException("solve : column function space and function space of solution don't match.");
199	} else if (in.getFunctionSpace() != getRowFunctionSpace()) {
200	throw FinleyAdapterException("solve : row function space and function space of right hand side don't match.");
201	}
202	out.expand();
203	in.expand();
204	double* out_dp=out.getSampleData(0);
205	double* in_dp=in.getSampleData(0);
206	Paso_solve(mat,out_dp,in_dp,&paso_options);
207	checkPasoError();
208	}
209
210	void SystemMatrixAdapter::nullifyRowsAndCols(escript::Data& row_q,escript::Data& col_q, const double mdv) const
211	{
212	Paso_SystemMatrix* mat = getPaso_SystemMatrix();
213	if ( col_q.getDataPointSize() != getColumnBlockSize()) {
214	throw FinleyAdapterException("nullifyRowsAndCols : column block size does not match the number of components of column mask.");
215	} else if ( row_q.getDataPointSize() != getRowBlockSize()) {
216	throw FinleyAdapterException("nullifyRowsAndCols : row block size does not match the number of components of row mask.");
217	} else if ( col_q.getFunctionSpace() != getColumnFunctionSpace()) {
218	throw FinleyAdapterException("nullifyRowsAndCols : column function space and function space of column mask don't match.");
219	} else if (row_q.getFunctionSpace() != getRowFunctionSpace()) {
220	throw FinleyAdapterException("nullifyRowsAndCols : row function space and function space of row mask don't match.");
221	}
222	row_q.expand();
223	col_q.expand();
224	double* row_q_dp=row_q.getSampleData(0);
225	double* col_q_dp=col_q.getSampleData(0);
226	Paso_SystemMatrix_nullifyRowsAndCols(mat,row_q_dp,col_q_dp, mdv);
227	checkPasoError();
228	}
229
230	void SystemMatrixAdapter::saveMM(const std::string& fileName) const
231	{
232	if( fileName.size() == 0 )
233	{
234	throw FinleyAdapterException("Null file name!");
235	}
236
237	char *fName = TMPMEMALLOC(fileName.size()+1,char);
238
239	strcpy(fName,fileName.c_str());
240	Paso_SystemMatrix* mat = getPaso_SystemMatrix();
241	Paso_SystemMatrix_saveMM(mat,fName);
242	checkPasoError();
243	TMPMEMFREE(fName);
244
245	}
246
247	void SystemMatrixAdapter::saveHB(const std::string& fileName) const
248	{
249	if( fileName.size() == 0 )
250	{
251	throw FinleyAdapterException("Null file name!");
252	}
253
254	char *fName = TMPMEMALLOC(fileName.size()+1,char);
255
256	strcpy(fName,fileName.c_str());
257	Paso_SystemMatrix* mat = getPaso_SystemMatrix();
258	Paso_SystemMatrix_saveHB(mat,fName);
259	checkPasoError();
260	TMPMEMFREE(fName);
261
262	}
263
264	void SystemMatrixAdapter::resetValues() const
265	{
266	Paso_SystemMatrix* mat = getPaso_SystemMatrix();
267	Paso_SystemMatrix_setValues(mat,0.);
268	Paso_solve_free(mat);
269	checkPasoError();
270	}
271
272	void SystemMatrixAdapter::dictToPasoOptions(Paso_Options* paso_options, const boost::python::dict& options)
273	{
274	Paso_Options_setDefaults(paso_options);
275	#define EXTRACT(__key__,__val__,__type__) if ( options.has_key(__key__)) paso_options->__val__=boost::python::extract<__type__>(options.get(__key__))
276	#define EXTRACT_OPTION(__key__,__val__,__type__) if ( options.has_key(__key__)) paso_options->__val__=mapOptionToPaso(boost::python::extract<__type__>(options.get(__key__)))
277	EXTRACT("verbose",verbose,int);
278	EXTRACT_OPTION("reordering",reordering,int);
279	EXTRACT(ESCRIPT_TOLERANCE_KEY,tolerance,double);
280	EXTRACT_OPTION(ESCRIPT_METHOD_KEY,method,int);
281	EXTRACT(ESCRIPT_SYMMETRY_KEY,symmetric,int);
282	EXTRACT_OPTION(ESCRIPT_PACKAGE_KEY,package,int);
283	EXTRACT_OPTION("preconditioner",preconditioner,int);
284	EXTRACT("iter_max",iter_max,int);
285	EXTRACT("drop_tolerance",drop_tolerance,double);
286	EXTRACT("drop_storage",drop_storage,double);
287	EXTRACT("truncation",truncation,int);
288	EXTRACT("restart",restart,int);
289	EXTRACT("sweeps",sweeps,int);
290	#undef EXTRACT
291	#undef EXTRACT_OPTION
292	}
293
294
295	} // end of namespace
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision