# Copyright (c) 2008-2022
# National Technology and Engineering Solutions of Sandia, LLC
# Under the terms of Contract DE-NA0003525 with National Technology and
# Engineering Solutions of Sandia, LLC, the U.S. Government retains certain
# rights in this software.
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
import pyomo.common.unittest as unittest
from pyomo.contrib.pynumero.dependencies import numpy as np, numpy_available
if not numpy_available:
raise unittest.SkipTest('pynumero MA27 tests require numpy')
import ctypes
from pyomo.contrib.pynumero.linalg.ma27 import MA27Interface
@unittest.skipIf(not MA27Interface.available(), reason='MA27 not available')
class TestMA27Interface(unittest.TestCase):
def test_get_cntl(self):
ma27 = MA27Interface()
self.assertEqual(ma27.get_icntl(1), 6)
self.assertAlmostEqual(ma27.get_cntl(1),
1e-1) # Numerical pivot threshold
self.assertAlmostEqual(ma27.get_cntl(3), 0.0) # Null pivot threshold
def test_set_icntl(self):
ma27 = MA27Interface()
ma27.set_icntl(5, 4) # Set output printing to max verbosity
ma27.set_icntl(8, 1) # Keep factors when we run out of space
# (so MA27ED can be used)
icntl5 = ma27.get_icntl(5)
import unittest
from pyomo.common.dependencies import attempt_import
import numpy as np
from scipy.sparse import coo_matrix, tril
import parapint
from pyomo.contrib.pynumero.linalg.ma27 import MA27Interface
ma27_available = MA27Interface.available()
mumps, mumps_available = attempt_import('mumps')
def get_base_matrix(use_tril):
if use_tril:
row = [0, 1, 1, 2, 2]
col = [0, 0, 1, 0, 2]
data = [1, 7, 4, 3, 6]
else:
row = [0, 0, 0, 1, 1, 2, 2]
col = [0, 1, 2, 0, 1, 0, 2]
data = [1, 7, 3, 7, 4, 3, 6]
mat = coo_matrix((data, (row, col)), shape=(3,3), dtype=np.double)
return mat
def get_base_matrix_wrong_order(use_tril):
if use_tril:
row = [1, 0, 1, 2, 2]
col = [0, 0, 1, 0, 2]
data = [7, 1, 4, 3, 6]
else:
row = [1, 0, 0, 0, 1, 2, 2]
class TestLinearSolvers(unittest.TestCase):
def create_blocks(self, m: np.ndarray, x: np.ndarray):
m = coo_matrix(m)
r = m * x
bm = BlockMatrix(2, 2)
bm.set_block(0, 0, m.copy())
bm.set_block(1, 1, m.copy())
br = BlockVector(2)
br.set_block(0, r.copy())
br.set_block(1, r.copy())
bx = BlockVector(2)
bx.set_block(0, x.copy())
bx.set_block(1, x.copy())
return bm, bx, br
def solve_helper(self, m: np.ndarray, x: np.ndarray, solver: LinearSolverInterface):
bm, bx, br = self.create_blocks(m, x)
bx2, res = solver.solve(bm, br)
self.assertEqual(res.status, LinearSolverStatus.successful)
err = np.max(np.abs(bx - bx2))
self.assertAlmostEqual(err, 0)
def symmetric_helper(self, solver: LinearSolverInterface):
m = np.array([[1, 2], [2, -1]], dtype=np.double)
x = np.array([4, 7], dtype=np.double)
self.solve_helper(m, x, solver)
def unsymmetric_helper(self, solver: LinearSolverInterface):
m = np.array([[1, 2], [0, -1]], dtype=np.double)
x = np.array([4, 7], dtype=np.double)
self.solve_helper(m, x, solver)
def singular_helper(self, solver: LinearSolverInterface):
m = np.array([[1, 1], [1, 1]], dtype=np.double)
x = np.array([4, 7], dtype=np.double)
bm, bx, br = self.create_blocks(m, x)
br.get_block(0)[1] += 1
br.get_block(1)[1] += 1
bx2, res = solver.solve(bm, br, raise_on_error=False)
self.assertNotEqual(res.status, LinearSolverStatus.successful)
@unittest.skipIf(not MA27Interface.available(), reason="MA27 not available")
def test_ma27(self):
solver = MA27()
self.symmetric_helper(solver)
self.singular_helper(solver)
@unittest.skipIf(not MA57Interface.available(), reason="MA57 not available")
def test_ma57(self):
solver = MA57()
self.symmetric_helper(solver)
self.singular_helper(solver)
def test_scipy_direct(self):
solver = ScipyLU()
self.symmetric_helper(solver)
self.unsymmetric_helper(solver)
self.singular_helper(solver)
def test_scipy_iterative(self):
solver = ScipyIterative(gmres)
solver.options["atol"] = 1e-8
self.symmetric_helper(solver)
self.unsymmetric_helper(solver)
self.singular_helper(solver)
@unittest.skipIf(not mumps_available, reason="mumps not available")
def test_mumps(self):
solver = MumpsCentralizedAssembledLinearSolver(sym=2)
self.symmetric_helper(solver)
self.singular_helper(solver)
solver = MumpsCentralizedAssembledLinearSolver(sym=0)
self.unsymmetric_helper(solver)