/** Initialize the local copy of the positions of the nonzero
elements */
ESymSolverStatus Ma27TSolverInterface::InitializeStructure(Index dim, Index nonzeros,
const Index* airn,
const Index* ajcn)
{
DBG_START_METH("Ma27TSolverInterface::InitializeStructure",dbg_verbosity);
ESymSolverStatus retval = SYMSOLVER_SUCCESS;
if (!warm_start_same_structure_) {
dim_ = dim;
nonzeros_ = nonzeros;
// Do the symbolic facotrization
retval = SymbolicFactorization(airn, ajcn);
if (retval != SYMSOLVER_SUCCESS ) {
return retval;
}
}
else {
ASSERT_EXCEPTION(dim_==dim && nonzeros_==nonzeros, INVALID_WARMSTART,
"Ma27TSolverInterface called with warm_start_same_structure, but the problem size has changed.");
}
initialized_ = true;
return retval;
}
/** Initialize the local copy of the positions of the nonzero
elements */
ESymSolverStatus
Ma57TSolverInterface::InitializeStructure(
Index dim,
Index nonzeros,
const Index* airn,
const Index* ajcn)
{
DBG_START_METH("Ma57TSolverInterface::InitializeStructure",dbg_verbosity);
ESymSolverStatus retval = SYMSOLVER_SUCCESS;
if (!warm_start_same_structure_) {
dim_ = dim;
nonzeros_ = nonzeros;
// for MA57, a_ only has to be as long as the number of nonzero
// elements
delete [] a_;
a_ = NULL;
a_ = new double [nonzeros_];
// Do the symbolic facotrization
retval = SymbolicFactorization(airn, ajcn);
if (retval != SYMSOLVER_SUCCESS ) {
return retval;
}
}
else {
ASSERT_EXCEPTION(dim_==dim && nonzeros_==nonzeros, INVALID_WARMSTART,
"Ma57TSolverInterface called with warm_start_same_structure, "
"but the problem size has changed.");
}
initialized_ = true;
return retval;
}
//=============================================================================
int Amesos_Dscpack::NumericFactorization()
{
IsNumericFactorizationOK_ = false;
if (!IsSymbolicFactorizationOK_)
AMESOS_CHK_ERR(SymbolicFactorization());
AMESOS_CHK_ERR(PerformNumericFactorization());
IsNumericFactorizationOK_ = true;
NumNumericFact_++;
return(0);
}
ESymSolverStatus MumpsSolverInterface::MultiSolve(bool new_matrix,
const Index* ia,
const Index* ja,
Index nrhs,
double* rhs_vals,
bool check_NegEVals,
Index numberOfNegEVals)
{
DBG_START_METH("MumpsSolverInterface::MultiSolve", dbg_verbosity);
DBG_ASSERT(!check_NegEVals || ProvidesInertia());
DBG_ASSERT(initialized_);
DBG_ASSERT(((DMUMPS_STRUC_C*)mumps_ptr_)->irn == ia);
DBG_ASSERT(((DMUMPS_STRUC_C*)mumps_ptr_)->jcn == ja);
if (pivtol_changed_) {
DBG_PRINT((1,"Pivot tolerance has changed.\n"));
pivtol_changed_ = false;
// If the pivot tolerance has been changed but the matrix is not
// new, we have to request the values for the matrix again to do
// the factorization again.
if (!new_matrix) {
DBG_PRINT((1,"Ask caller to call again.\n"));
refactorize_ = true;
return SYMSOLVER_CALL_AGAIN;
}
}
// check if a factorization has to be done
DBG_PRINT((1, "new_matrix = %d\n", new_matrix));
if (new_matrix || refactorize_) {
ESymSolverStatus retval;
// Do the symbolic facotrization if it hasn't been done yet
if (!have_symbolic_factorization_) {
retval = SymbolicFactorization();
if (retval != SYMSOLVER_SUCCESS ) {
return retval;
}
have_symbolic_factorization_ = true;
}
// perform the factorization
retval = Factorization(check_NegEVals, numberOfNegEVals);
if (retval != SYMSOLVER_SUCCESS) {
DBG_PRINT((1, "FACTORIZATION FAILED!\n"));
return retval; // Matrix singular or error occurred
}
refactorize_ = false;
}
// do the solve
return Solve(nrhs, rhs_vals);
}
int Amesos_Mumps::NumericFactorization()
{
IsNumericFactorizationOK_ = false;
if (IsSymbolicFactorizationOK_ == false)
AMESOS_CHK_ERR(SymbolicFactorization());
RedistrMatrix(true);
AMESOS_CHK_ERR(ConvertToTriplet(true));
if (Comm().NumProc() != 1)
{
if (Comm().MyPID() < MaxProcs_)
MDS.a_loc = &Val[0];
}
else
MDS.a = &Val[0];
// Request numeric factorization
MDS.job = 2;
// Perform numeric factorization
ResetTimer();
if (Comm().MyPID() < MaxProcs_) {
dmumps_c(&(MDS));
}
NumFactTime_ = AddTime("Total numeric factorization time", NumFactTime_);
int IntWrong = CheckError()?1:0 ;
int AnyWrong;
Comm().SumAll( &IntWrong, &AnyWrong, 1 ) ;
bool Wrong = AnyWrong > 0 ;
if ( Wrong ) {
AMESOS_CHK_ERR( NumericallySingularMatrixError ) ;
}
IsNumericFactorizationOK_ = true;
NumNumericFact_++;
return(0);
}
/** Initialize the local copy of the positions of the nonzero
elements */
ESymSolverStatus WsmpSolverInterface::InitializeStructure
(Index dim, Index nonzeros,
const Index* ia,
const Index* ja)
{
DBG_START_METH("WsmpSolverInterface::InitializeStructure",dbg_verbosity);
dim_ = dim;
// Make space for storing the matrix elements
delete[] a_;
a_ = new double[nonzeros];
// Do the symbolic facotrization
ESymSolverStatus retval = SymbolicFactorization(ia, ja);
if (retval != SYMSOLVER_SUCCESS) {
return retval;
}
initialized_ = true;
return retval;
}
//=============================================================================
int Amesos_Klu::NumericFactorization()
{
if ( !TrustMe_ )
{
IsNumericFactorizationOK_ = false;
if (IsSymbolicFactorizationOK_ == false)
AMESOS_CHK_ERR(SymbolicFactorization());
ResetTimer(1); // "overhead" time
Epetra_CrsMatrix *CrsMatrixA = dynamic_cast<Epetra_CrsMatrix *>(RowMatrixA_);
if ( CrsMatrixA == 0 ) // hack to get around Bug #1502
AMESOS_CHK_ERR( CreateLocalMatrixAndExporters() ) ;
assert( NumGlobalElements_ == RowMatrixA_->NumGlobalCols() );
if ( AddZeroToDiag_ == 0 )
assert( numentries_ == RowMatrixA_->NumGlobalNonzeros() );
AMESOS_CHK_ERR( ExportToSerial() );
if ( CrsMatrixA == 0 ) { // continuation of hack to avoid bug #1502
AMESOS_CHK_ERR( ConvertToKluCRS(true) );
} else {
AMESOS_CHK_ERR( ConvertToKluCRS(false) );
}
OverheadTime_ = AddTime("Total Amesos overhead time", OverheadTime_, 1);
}
// this time is all for KLU
AMESOS_CHK_ERR( PerformNumericFactorization() );
NumNumericFact_++;
IsNumericFactorizationOK_ = true;
return 0;
}
ESymSolverStatus MumpsSolverInterface::
DetermineDependentRows(const Index* ia, const Index* ja,
std::list<Index>& c_deps)
{
DBG_START_METH("MumpsSolverInterface::DetermineDependentRows",
dbg_verbosity);
DMUMPS_STRUC_C* mumps_data = (DMUMPS_STRUC_C*)mumps_ptr_;
c_deps.clear();
ESymSolverStatus retval;
// Do the symbolic facotrization if it hasn't been done yet
if (!have_symbolic_factorization_) {
const Index mumps_permuting_scaling_orig = mumps_permuting_scaling_;
const Index mumps_scaling_orig = mumps_scaling_;
mumps_permuting_scaling_ = 0;
mumps_scaling_ = 6;
retval = SymbolicFactorization();
mumps_permuting_scaling_ = mumps_permuting_scaling_orig;
mumps_scaling_ = mumps_scaling_orig;
if (retval != SYMSOLVER_SUCCESS ) {
return retval;
}
have_symbolic_factorization_ = true;
}
// perform the factorization, in order to find dependent rows/columns
//Set flags to ask MUMPS for checking linearly dependent rows
mumps_data->icntl[23] = 1;
mumps_data->cntl[2] = mumps_dep_tol_;
mumps_data->job = 2;//numerical factorization
dump_matrix(mumps_data);
dmumps_c(mumps_data);
int error = mumps_data->info[0];
//Check for errors
if (error == -8 || error == -9) {//not enough memory
const Index trycount_max = 20;
for (int trycount=0; trycount<trycount_max; trycount++) {
Jnlst().Printf(J_WARNING, J_LINEAR_ALGEBRA,
"MUMPS returned INFO(1) = %d and requires more memory, reallocating. Attempt %d\n",
error,trycount+1);
Jnlst().Printf(J_WARNING, J_LINEAR_ALGEBRA,
" Increasing icntl[13] from %d to ", mumps_data->icntl[13]);
double mem_percent = mumps_data->icntl[13];
mumps_data->icntl[13] = (Index)(2.0 * mem_percent);
Jnlst().Printf(J_WARNING, J_LINEAR_ALGEBRA, "%d.\n", mumps_data->icntl[13]);
dump_matrix(mumps_data);
dmumps_c(mumps_data);
error = mumps_data->info[0];
if (error != -8 && error != -9)
break;
}
if (error == -8 || error == -9) {
Jnlst().Printf(J_ERROR, J_LINEAR_ALGEBRA,
"MUMPS was not able to obtain enough memory.\n");
// Reset flags
mumps_data->icntl[23] = 0;
return SYMSOLVER_FATAL_ERROR;
}
}
// Reset flags
mumps_data->icntl[23] = 0;
if (error < 0) {//some other error
Jnlst().Printf(J_ERROR, J_LINEAR_ALGEBRA,
"MUMPS returned INFO(1) =%d MUMPS failure.\n",
error);
return SYMSOLVER_FATAL_ERROR;
}
const Index n_deps = mumps_data->infog[27];
for (Index i=0; i<n_deps; i++) {
c_deps.push_back(mumps_data->pivnul_list[i]-1);
}
return SYMSOLVER_SUCCESS;
}