ESymSolverStatus IterativePardisoSolverInterface::MultiSolve(bool new_matrix,
const Index* ia,
const Index* ja,
Index nrhs,
double* rhs_vals,
bool check_NegEVals,
Index numberOfNegEVals)
{
DBG_START_METH("IterativePardisoSolverInterface::MultiSolve",dbg_verbosity);
DBG_ASSERT(!check_NegEVals || ProvidesInertia());
DBG_ASSERT(initialized_);
// check if a factorization has to be done
if (new_matrix) {
// perform the factorization
ESymSolverStatus retval;
retval = Factorization(ia, ja, check_NegEVals, numberOfNegEVals);
if (retval!=SYMSOLVER_SUCCESS) {
DBG_PRINT((1, "FACTORIZATION FAILED!\n"));
return retval; // Matrix singular or error occurred
}
}
// do the solve
return Solve(ia, ja, nrhs, rhs_vals);
}
Index Ma27TSolverInterface::NumberOfNegEVals() const
{
DBG_START_METH("Ma27TSolverInterface::NumberOfNegEVals",dbg_verbosity);
DBG_ASSERT(ProvidesInertia());
DBG_ASSERT(initialized_);
return negevals_;
}
ESymSolverStatus WsmpSolverInterface::MultiSolve(
bool new_matrix,
const Index* ia,
const Index* ja,
Index nrhs,
double* rhs_vals,
bool check_NegEVals,
Index numberOfNegEVals)
{
DBG_START_METH("WsmpSolverInterface::MultiSolve",dbg_verbosity);
DBG_ASSERT(!check_NegEVals || ProvidesInertia());
DBG_ASSERT(initialized_);
if (!printed_num_threads_) {
Jnlst().Printf(J_ITERSUMMARY, J_LINEAR_ALGEBRA,
" -- WSMP is working with %d thread%s.\n", IPARM_[32],
IPARM_[32]==1 ? "" : "s");
printed_num_threads_ = true;
}
// check if a factorization has to be done
if (new_matrix || pivtol_changed_) {
pivtol_changed_ = false;
// perform the factorization
ESymSolverStatus retval;
retval = Factorization(ia, ja, check_NegEVals, numberOfNegEVals);
if (retval!=SYMSOLVER_SUCCESS) {
DBG_PRINT((1, "FACTORIZATION FAILED!\n"));
return retval; // Matrix singular or error occurred
}
}
// do the solve
return Solve(ia, ja, nrhs, rhs_vals);
}
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);
}
ESymSolverStatus Ma27TSolverInterface::MultiSolve(bool new_matrix,
const Index* airn,
const Index* ajcn,
Index nrhs,
double* rhs_vals,
bool check_NegEVals,
Index numberOfNegEVals)
{
DBG_START_METH("Ma27TSolverInterface::MultiSolve",dbg_verbosity);
DBG_ASSERT(!check_NegEVals || ProvidesInertia());
DBG_ASSERT(initialized_);
DBG_ASSERT(la_!=0);
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_) {
// perform the factorization
ESymSolverStatus retval;
retval = Factorization(airn, ajcn, check_NegEVals, numberOfNegEVals);
if (retval!=SYMSOLVER_SUCCESS) {
DBG_PRINT((1, "FACTORIZATION FAILED!\n"));
return retval; // Matrix singular or error occurred
}
refactorize_ = false;
}
// do the backsolve
return Backsolve(nrhs, rhs_vals);
}
ESymSolverStatus
TSymLinearSolver::MultiSolve(const SymMatrix& sym_A,
std::vector<SmartPtr<const Vector> >& rhsV,
std::vector<SmartPtr<Vector> >& solV,
bool check_NegEVals,
Index numberOfNegEVals)
{
DBG_START_METH("TSymLinearSolver::MultiSolve",dbg_verbosity);
DBG_ASSERT(!check_NegEVals || ProvidesInertia());
// Check if this object has ever seen a matrix If not,
// allocate memory of the matrix structure and copy the nonzeros
// structure (it is assumed that this will never change).
if (!initialized_) {
ESymSolverStatus retval = InitializeStructure(sym_A);
if (retval != SYMSOLVER_SUCCESS) {
return retval;
}
}
DBG_ASSERT(nonzeros_triplet_== TripletHelper::GetNumberEntries(sym_A));
// Check if the matrix has been changed
DBG_PRINT((1,"atag_=%d sym_A->GetTag()=%d\n",atag_,sym_A.GetTag()));
bool new_matrix = sym_A.HasChanged(atag_);
atag_ = sym_A.GetTag();
// If a new matrix is encountered, get the array for storing the
// entries from the linear solver interface, fill in the new
// values, compute the new scaling factors (if required), and
// scale the matrix
if (new_matrix || just_switched_on_scaling_) {
GiveMatrixToSolver(true, sym_A);
new_matrix = true;
}
// Retrieve the right hand sides and scale if required
Index nrhs = (Index)rhsV.size();
double* rhs_vals = new double[dim_*nrhs];
for (Index irhs=0; irhs<nrhs; irhs++) {
TripletHelper::FillValuesFromVector(dim_, *rhsV[irhs],
&rhs_vals[irhs*(dim_)]);
if (Jnlst().ProduceOutput(J_MOREMATRIX, J_LINEAR_ALGEBRA)) {
Jnlst().Printf(J_MOREMATRIX, J_LINEAR_ALGEBRA,
"Right hand side %d in TSymLinearSolver:\n", irhs);
for (Index i=0; i<dim_; i++) {
Jnlst().Printf(J_MOREMATRIX, J_LINEAR_ALGEBRA,
"Trhs[%5d,%5d] = %23.16e\n", irhs, i,
rhs_vals[irhs*(dim_)+i]);
}
}
if (use_scaling_) {
if (HaveIpData()) {
IpData().TimingStats().LinearSystemScaling().Start();
}
for (Index i=0; i<dim_; i++) {
rhs_vals[irhs*(dim_)+i] *= scaling_factors_[i];
}
if (HaveIpData()) {
IpData().TimingStats().LinearSystemScaling().End();
}
}
}
bool done = false;
// Call the linear solver through the interface to solve the
// system. This is repeated, if the return values is S_CALL_AGAIN
// after the values have been restored (this might be necessary
// for MA27 if the size of the work space arrays was not large
// enough).
ESymSolverStatus retval;
while (!done) {
const Index* ia;
const Index* ja;
if (matrix_format_==SparseSymLinearSolverInterface::Triplet_Format) {
ia = airn_;
ja = ajcn_;
}
else {
if (HaveIpData()) {
IpData().TimingStats().LinearSystemStructureConverter().Start();
}
ia = triplet_to_csr_converter_->IA();
ja = triplet_to_csr_converter_->JA();
if (HaveIpData()) {
IpData().TimingStats().LinearSystemStructureConverter().End();
}
}
retval = solver_interface_->MultiSolve(new_matrix, ia, ja,
nrhs, rhs_vals, check_NegEVals,
numberOfNegEVals);
if (retval==SYMSOLVER_CALL_AGAIN) {
DBG_PRINT((1, "Solver interface asks to be called again.\n"));
GiveMatrixToSolver(false, sym_A);
}
else {
done = true;
}
}
// If the solve was successful, unscale the solution (if required)
// and transfer the result into the Vectors
if (retval==SYMSOLVER_SUCCESS) {
for (Index irhs=0; irhs<nrhs; irhs++) {
if (use_scaling_) {
if (HaveIpData()) {
IpData().TimingStats().LinearSystemScaling().Start();
}
for (Index i=0; i<dim_; i++) {
rhs_vals[irhs*(dim_)+i] *= scaling_factors_[i];
}
if (HaveIpData()) {
IpData().TimingStats().LinearSystemScaling().End();
}
}
if (Jnlst().ProduceOutput(J_MOREMATRIX, J_LINEAR_ALGEBRA)) {
Jnlst().Printf(J_MOREMATRIX, J_LINEAR_ALGEBRA,
"Solution %d in TSymLinearSolver:\n", irhs);
for (Index i=0; i<dim_; i++) {
Jnlst().Printf(J_MOREMATRIX, J_LINEAR_ALGEBRA,
"Tsol[%5d,%5d] = %23.16e\n", irhs, i,
rhs_vals[irhs*(dim_)+i]);
}
}
TripletHelper::PutValuesInVector(dim_, &rhs_vals[irhs*(dim_)],
*solV[irhs]);
}
}
delete[] rhs_vals;
return retval;
}
