void LASError(LASErrIdType ErrId, char *ProcName, char *Object1Name, char *Object2Name, char *Object3Name) /* Set error status to ErrId, ... */ { LASErrId = ErrId; /* release current values of error variables */ if (LASProcName != NULL) free(LASProcName); if (LASObject1Name != NULL) free(LASObject1Name); if (LASObject2Name != NULL) free(LASObject2Name); if (LASObject3Name != NULL) free(LASObject2Name); LASProcName = NULL; LASObject1Name = NULL; LASObject2Name = NULL; LASObject3Name = NULL; LASProcName = (char *)malloc((strlen(ProcName) + 1) * sizeof(char)); if (LASProcName != NULL) { strcpy(LASProcName, ProcName); if (Object1Name != NULL && strlen(Object1Name) > 0) { LASObject1Name = (char *)malloc((strlen(Object1Name) + 1) * sizeof(char)); if (LASObject1Name != NULL) strcpy(LASObject1Name, Object1Name); } if (Object2Name != NULL && strlen(Object2Name) > 0) { LASObject2Name = (char *)malloc((strlen(Object2Name) + 1) * sizeof(char)); if (LASObject2Name != NULL) strcpy(LASObject2Name, Object2Name); } if (Object3Name != NULL && strlen(Object3Name) > 0) { LASObject3Name = (char *)malloc((strlen(Object3Name) + 1) * sizeof(char)); if (LASObject3Name != NULL) strcpy(LASObject3Name, Object3Name); } } else { strcpy(LASProcName, "(procedure unknown)"); } WriteLASErrDescr(stderr); }
std::pair<unsigned int, Real> LaspackLinearSolver<T>::adjoint_solve (SparseMatrix<T> &matrix_in, NumericVector<T> &solution_in, NumericVector<T> &rhs_in, const double tol, const unsigned int m_its) { START_LOG("adjoint_solve()", "LaspackLinearSolver"); this->init (); // Make sure the data passed in are really in Laspack types LaspackMatrix<T>* matrix = cast_ptr<LaspackMatrix<T>*>(&matrix_in); LaspackVector<T>* solution = cast_ptr<LaspackVector<T>*>(&solution_in); LaspackVector<T>* rhs = cast_ptr<LaspackVector<T>*>(&rhs_in); // Zero-out the solution to prevent the solver from exiting in 0 // iterations (?) //TODO:[BSK] Why does Laspack do this? Comment out this and try ex13... solution->zero(); // Close the matrix and vectors in case this wasn't already done. matrix->close (); solution->close (); rhs->close (); // Set the preconditioner type this->set_laspack_preconditioner_type (); // Set the solver tolerance SetRTCAccuracy (tol); // Solve the linear system switch (this->_solver_type) { // Conjugate-Gradient case CG: { CGIter (Transp_Q(&matrix->_QMat), &solution->_vec, &rhs->_vec, m_its, _precond_type, 1.); break; } // Conjugate-Gradient Normalized case CGN: { CGNIter (Transp_Q(&matrix->_QMat), &solution->_vec, &rhs->_vec, m_its, _precond_type, 1.); break; } // Conjugate-Gradient Squared case CGS: { CGSIter (Transp_Q(&matrix->_QMat), &solution->_vec, &rhs->_vec, m_its, _precond_type, 1.); break; } // Bi-Conjugate Gradient case BICG: { BiCGIter (Transp_Q(&matrix->_QMat), &solution->_vec, &rhs->_vec, m_its, _precond_type, 1.); break; } // Bi-Conjugate Gradient Stabilized case BICGSTAB: { BiCGSTABIter (Transp_Q(&matrix->_QMat), &solution->_vec, &rhs->_vec, m_its, _precond_type, 1.); break; } // Quasi-Minimum Residual case QMR: { QMRIter (Transp_Q(&matrix->_QMat), &solution->_vec, &rhs->_vec, m_its, _precond_type, 1.); break; } // Symmetric over-relaxation case SSOR: { SSORIter (Transp_Q(&matrix->_QMat), &solution->_vec, &rhs->_vec, m_its, _precond_type, 1.); break; } // Jacobi Relaxation case JACOBI: { JacobiIter (Transp_Q(&matrix->_QMat), &solution->_vec, &rhs->_vec, m_its, _precond_type, 1.); break; } // Generalized Minimum Residual case GMRES: { SetGMRESRestart (30); GMRESIter (Transp_Q(&matrix->_QMat), &solution->_vec, &rhs->_vec, m_its, _precond_type, 1.); break; } // Unknown solver, use GMRES default: { libMesh::err << "ERROR: Unsupported LASPACK Solver: " << Utility::enum_to_string(this->_solver_type) << std::endl << "Continuing with GMRES" << std::endl; this->_solver_type = GMRES; return this->solve (*matrix, *solution, *rhs, tol, m_its); } } // Check for an error if (LASResult() != LASOK) { WriteLASErrDescr(stdout); libmesh_error_msg("Exiting after LASPACK Error!"); } STOP_LOG("adjoint_solve()", "LaspackLinearSolver"); // Get the convergence step # and residual return std::make_pair(GetLastNoIter(), GetLastAccuracy()); }