def testDoublePassG(self):
        d, U = doublePassG(self.Hop,
                           self.M,
                           self.Minv,
                           self.Omega,
                           self.k_evec,
                           s=2)
        nvec = U.nvec()
        AU = MultiVector(U[0], nvec)
        BU = MultiVector(U[0], nvec)
        MatMvMult(self.Hop, U, AU)
        MatMvMult(self.M, U, BU)

        # Residual checks
        diff = MultiVector(AU)
        diff.axpy(-d, BU)
        res_norms = diff.norm("l2")
        # B-orthogonality
        UtBU = BU.dot_mv(U)
        err = UtBU - np.eye(nvec, dtype=UtBU.dtype)
        err_Bortho = np.linalg.norm(err, 'fro')
        # A-orthogonality
        V = MultiVector(U)
        scaling = np.power(np.abs(d), -0.5)
        V.scale(scaling)
        AU.scale(scaling)
        VtAV = AU.dot_mv(V)
        err = VtAV - np.diag(np.sign(d))
        err_Aortho = np.linalg.norm(err, 'fro')

        assert err_Bortho < 1e-8
        assert err_Aortho < 1e-4
        assert np.all(res_norms < 1e-4)
Example #2
0
    def testBOrthogonalization(self):
        myRandom = Random(self.mpi_rank, self.mpi_size)
        myRandom.normal(1.,self.Q)
        self.Q.Borthogonalize(self.M)
        
        MQ = MultiVector(self.Q)
        MQ.zero()
        MatMvMult(self.M, self.Q, MQ)
        
        QtMQ = self.Q.dot_mv(MQ)

        if self.mpi_rank == 0:
            assert np.linalg.norm(QtMQ - np.eye(QtMQ.shape[0])) < 1e-8