basic solver for Ax = b which has to reimplemented for different linear algebra libraries More...

#include <linear_solver_cholmod.h>

Inheritance diagram for g2o::LinearSolverCholmod< MatrixType >:

[legend]

Collaboration diagram for g2o::LinearSolverCholmod< MatrixType >:

[legend]

Public Member Functions
	LinearSolverCholmod ()

	LinearSolverCholmod (LinearSolverCholmod< MatrixType > const &)=delete

LinearSolverCholmod &	operator= (LinearSolverCholmod< MatrixType > const &)=delete

virtual	~LinearSolverCholmod ()

virtual bool	init ()

bool	solve (const SparseBlockMatrix< MatrixType > &A, double x, double b)

virtual bool	saveMatrix (const std::string &fileName)

Public Member Functions inherited from g2o::LinearSolverCCS< MatrixType >
	LinearSolverCCS ()

	~LinearSolverCCS ()

virtual bool	solveBlocks (double **&blocks, const SparseBlockMatrix< MatrixType > &A)

virtual bool	solvePattern (SparseBlockMatrix< MatrixX > &spinv, const std::vector< std::pair< int, int > > &blockIndices, const SparseBlockMatrix< MatrixType > &A)

bool	blockOrdering () const
	do the AMD ordering on the blocks or on the scalar matrix

void	setBlockOrdering (bool blockOrdering)

Public Member Functions inherited from g2o::LinearSolver< MatrixType >
	LinearSolver ()

virtual	~LinearSolver ()

bool	writeDebug () const
	write a debug dump of the system matrix if it is not PSD in solve

void	setWriteDebug (bool b)

Protected Member Functions
void	computeSymbolicDecomposition (const SparseBlockMatrix< MatrixType > &A)

void	fillCholmodExt (const SparseBlockMatrix< MatrixType > &A, bool onlyValues)

bool	computeCholmodFactor (const SparseBlockMatrix< MatrixType > &A, double &t)
	compute the cholmodFactor for the given matrix A

bool	solveBlocks_impl (const SparseBlockMatrix< MatrixType > &A, std::function< void(MarginalCovarianceCholesky &)> compute)

void	freeCholdmodFactor ()

Protected Member Functions inherited from g2o::LinearSolverCCS< MatrixType >
void	initMatrixStructure (const SparseBlockMatrix< MatrixType > &A)

Protected Attributes
cholmod::Cholmod	_cholmod

MatrixStructure	_matrixStructure

VectorXI	_scalarPermutation

VectorXI	_blockPermutation

Protected Attributes inherited from g2o::LinearSolverCCS< MatrixType >
SparseBlockMatrixCCS< MatrixType > *	_ccsMatrix

bool	_blockOrdering

Protected Attributes inherited from g2o::LinearSolver< MatrixType >
bool	_writeDebug

Additional Inherited Members
Static Public Member Functions inherited from g2o::LinearSolver< MatrixType >
static void	allocateBlocks (const SparseBlockMatrix< MatrixType > &A, double **&blocks)
	allocate block memory structure

static void	deallocateBlocks (const SparseBlockMatrix< MatrixType > &A, double **&blocks)
	de-allocate the block structure

template<typename BlockDerived , typename ScalarDerived >
static void	blockToScalarPermutation (const SparseBlockMatrix< MatrixType > &A, const Eigen::MatrixBase< BlockDerived > &p, const Eigen::MatrixBase< ScalarDerived > &scalar)

Detailed Description

template<typename MatrixType>
class g2o::LinearSolverCholmod< MatrixType >

basic solver for Ax = b which has to reimplemented for different linear algebra libraries

Definition at line 47 of file linear_solver_cholmod.h.

Constructor & Destructor Documentation

◆ LinearSolverCholmod() [1/2]

template<typename MatrixType >

g2o::LinearSolverCholmod< MatrixType >::LinearSolverCholmod ( )

inline

Definition at line 49 of file linear_solver_cholmod.h.

49: LinearSolverCCS<MatrixType>() {}

◆ LinearSolverCholmod() [2/2]

template<typename MatrixType >

g2o::LinearSolverCholmod< MatrixType >::LinearSolverCholmod ( LinearSolverCholmod< MatrixType > const & )

delete

◆ ~LinearSolverCholmod()

template<typename MatrixType >

virtual g2o::LinearSolverCholmod< MatrixType >::~LinearSolverCholmod ( )

inlinevirtual

Definition at line 55 of file linear_solver_cholmod.h.

55{ freeCholdmodFactor(); }

g2o::LinearSolverCholmod::freeCholdmodFactor

void freeCholdmodFactor()

Definition linear_solver_cholmod.h:222

References g2o::LinearSolverCholmod< MatrixType >::freeCholdmodFactor().

Member Function Documentation

◆ computeCholmodFactor()

template<typename MatrixType >

bool g2o::LinearSolverCholmod< MatrixType >::computeCholmodFactor	(	const SparseBlockMatrix< MatrixType > &	A,
		double &	t
	)

inlineprotected

compute the cholmodFactor for the given matrix A

Definition at line 164 of file linear_solver_cholmod.h.

                                                                               {
    // _cholmodFactor used as bool, if not existing will copy the whole
    // structure, otherwise only the values
    bool hasFactor = _cholmod.hasFactor();
    fillCholmodExt(A, hasFactor);
 
    if (!hasFactor) {
      computeSymbolicDecomposition(A);
      assert(_cholmod.hasFactor() && "Symbolic cholesky failed");
    }
 
    t = get_monotonic_time();
    bool factorStatus = _cholmod.factorize();
    if (!factorStatus) {
      if (this->writeDebug()) {
        G2O_ERROR(
            "Cholesky failure, writing debug.txt (Hessian loadable by Octave)");
        saveMatrix("debug.txt");
      } else {
        G2O_DEBUG("Cholesky failure");
      }
      return false;
    }
    return true;
  }

References g2o::LinearSolverCholmod< MatrixType >::_cholmod, g2o::LinearSolverCholmod< MatrixType >::computeSymbolicDecomposition(), g2o::cholmod::Cholmod::factorize(), g2o::LinearSolverCholmod< MatrixType >::fillCholmodExt(), G2O_DEBUG, G2O_ERROR, g2o::get_monotonic_time(), g2o::cholmod::Cholmod::hasFactor(), g2o::LinearSolverCholmod< MatrixType >::saveMatrix(), and g2o::LinearSolver< MatrixType >::writeDebug().

Referenced by g2o::LinearSolverCholmod< MatrixType >::solve(), and g2o::LinearSolverCholmod< MatrixType >::solveBlocks_impl().

◆ computeSymbolicDecomposition()

template<typename MatrixType >

void g2o::LinearSolverCholmod< MatrixType >::computeSymbolicDecomposition ( const SparseBlockMatrix< MatrixType > & A )

inlineprotected

Definition at line 91 of file linear_solver_cholmod.h.

                                                                            {
    double t = get_monotonic_time();
    if (!this->blockOrdering()) {
      _cholmod.analyze();
    } else {
      A.fillBlockStructure(_matrixStructure);
 
      // get the ordering for the block matrix
      if (_blockPermutation.size() == 0)
        _blockPermutation.resize(_matrixStructure.n);
      if (_blockPermutation.size() <
          _matrixStructure.n)  // double space if resizing
        _blockPermutation.resize(2 * _matrixStructure.n);
 
      // prepare AMD call via CHOLMOD
      size_t structureDim = _matrixStructure.n;
      size_t structureNz = _matrixStructure.nzMax();
      size_t structureAllocated = structureDim;
      double* structureX = nullptr;
      cholmod::Cholmod::SparseView amdView(
          structureDim, structureDim, structureNz, _matrixStructure.Ap,
          _matrixStructure.Aii, structureX, structureAllocated);
      bool amdStatus = _cholmod.amd(amdView, _blockPermutation.data());
      if (!amdStatus) return;
 
      // blow up the permutation to the scalar matrix
      this->blockToScalarPermutation(A, _blockPermutation, _scalarPermutation);
 
      // apply the ordering
      _cholmod.analyze_p(_scalarPermutation.data());
    }
    G2OBatchStatistics* globalStats = G2OBatchStatistics::globalStats();
    if (globalStats)
      globalStats->timeSymbolicDecomposition = get_monotonic_time() - t;
  }

References g2o::LinearSolverCholmod< MatrixType >::_blockPermutation, g2o::LinearSolverCholmod< MatrixType >::_cholmod, g2o::LinearSolverCholmod< MatrixType >::_matrixStructure, g2o::LinearSolverCholmod< MatrixType >::_scalarPermutation, g2o::MatrixStructure::Aii, g2o::cholmod::Cholmod::amd(), g2o::cholmod::Cholmod::analyze(), g2o::cholmod::Cholmod::analyze_p(), g2o::MatrixStructure::Ap, g2o::LinearSolverCCS< MatrixType >::blockOrdering(), g2o::LinearSolver< MatrixType >::blockToScalarPermutation(), g2o::SparseBlockMatrix< MatrixType >::fillBlockStructure(), g2o::get_monotonic_time(), g2o::G2OBatchStatistics::globalStats(), g2o::MatrixStructure::n, g2o::MatrixStructure::nzMax(), and g2o::G2OBatchStatistics::timeSymbolicDecomposition.

Referenced by g2o::LinearSolverCholmod< MatrixType >::computeCholmodFactor().

◆ fillCholmodExt()

template<typename MatrixType >

void g2o::LinearSolverCholmod< MatrixType >::fillCholmodExt	(	const SparseBlockMatrix< MatrixType > &	A,
		bool	onlyValues
	)

inlineprotected

Definition at line 127 of file linear_solver_cholmod.h.

                                                                               {
    if (!onlyValues) this->initMatrixStructure(A);
    size_t m = A.rows();
    size_t n = A.cols();
    assert(m > 0 && n > 0 && "Hessian has 0 rows/cols");
 
    cholmod::Cholmod::SparseView cholmodSparse = _cholmod.sparseView();
 
    if (cholmodSparse.columnsAllocated < n) {
      // pre-allocate more space if re-allocating
      cholmodSparse.columnsAllocated =
          cholmodSparse.columnsAllocated == 0 ? n : 2 * n;
      delete[] cholmodSparse.p;
      cholmodSparse.p = new int[cholmodSparse.columnsAllocated + 1];
    }
    if (!onlyValues) {
      size_t nzmax = A.nonZeros();
      if (cholmodSparse.nzmax < nzmax) {
        // pre-allocate more space if re-allocating
        cholmodSparse.nzmax = cholmodSparse.nzmax == 0 ? nzmax : 2 * nzmax;
        delete[] cholmodSparse.x;
        delete[] cholmodSparse.i;
        cholmodSparse.i = new int[cholmodSparse.nzmax];
        cholmodSparse.x = new double[cholmodSparse.nzmax];
      }
    }
    cholmodSparse.ncol = n;
    cholmodSparse.nrow = m;
 
    if (onlyValues)
      this->_ccsMatrix->fillCCS((double*)cholmodSparse.x, true);
    else
      this->_ccsMatrix->fillCCS((int*)cholmodSparse.p, (int*)cholmodSparse.i,
                                (double*)cholmodSparse.x, true);
  }

References g2o::LinearSolverCCS< MatrixType >::_ccsMatrix, g2o::LinearSolverCholmod< MatrixType >::_cholmod, g2o::SparseBlockMatrix< MatrixType >::cols(), g2o::cholmod::Cholmod::SparseView::columnsAllocated, g2o::cholmod::Cholmod::SparseView::i, g2o::LinearSolverCCS< MatrixType >::initMatrixStructure(), g2o::cholmod::Cholmod::SparseView::ncol, g2o::SparseBlockMatrix< MatrixType >::nonZeros(), g2o::cholmod::Cholmod::SparseView::nrow, g2o::cholmod::Cholmod::SparseView::nzmax, g2o::cholmod::Cholmod::SparseView::p, g2o::SparseBlockMatrix< MatrixType >::rows(), g2o::cholmod::Cholmod::sparseView(), and g2o::cholmod::Cholmod::SparseView::x.

Referenced by g2o::LinearSolverCholmod< MatrixType >::computeCholmodFactor().

◆ freeCholdmodFactor()

template<typename MatrixType >

void g2o::LinearSolverCholmod< MatrixType >::freeCholdmodFactor ( )

inlineprotected

Definition at line 222 of file linear_solver_cholmod.h.

222{ _cholmod.freeFactor(); }

g2o::cholmod::Cholmod::freeFactor

void freeFactor()

Definition cholmod_wrapper.cpp:74

References g2o::LinearSolverCholmod< MatrixType >::_cholmod, and g2o::cholmod::Cholmod::freeFactor().

Referenced by g2o::LinearSolverCholmod< MatrixType >::init(), and g2o::LinearSolverCholmod< MatrixType >::~LinearSolverCholmod().

◆ init()

template<typename MatrixType >

virtual bool g2o::LinearSolverCholmod< MatrixType >::init ( )

inlinevirtual

init for operating on matrices with a different non-zero pattern like before

Implements g2o::LinearSolver< MatrixType >.

Definition at line 57 of file linear_solver_cholmod.h.

                      {
    freeCholdmodFactor();
    return true;
  }

References g2o::LinearSolverCholmod< MatrixType >::freeCholdmodFactor().

◆ operator=()

template<typename MatrixType >

LinearSolverCholmod & g2o::LinearSolverCholmod< MatrixType >::operator= ( LinearSolverCholmod< MatrixType > const & )

delete

◆ saveMatrix()

template<typename MatrixType >

virtual bool g2o::LinearSolverCholmod< MatrixType >::saveMatrix ( const std::string & fileName )

inlinevirtual

Definition at line 78 of file linear_solver_cholmod.h.

                                                     {
    cholmod::Cholmod::SparseView sparseView = _cholmod.sparseView();
    writeCCSMatrix(fileName, sparseView.nrow, sparseView.ncol, sparseView.p,
                   sparseView.i, sparseView.x, true);
    return true;
  }

References g2o::LinearSolverCholmod< MatrixType >::_cholmod, g2o::cholmod::Cholmod::SparseView::i, g2o::cholmod::Cholmod::SparseView::ncol, g2o::cholmod::Cholmod::SparseView::nrow, g2o::cholmod::Cholmod::SparseView::p, g2o::cholmod::Cholmod::sparseView(), g2o::writeCCSMatrix(), and g2o::cholmod::Cholmod::SparseView::x.

Referenced by g2o::LinearSolverCholmod< MatrixType >::computeCholmodFactor().

◆ solve()

template<typename MatrixType >

bool g2o::LinearSolverCholmod< MatrixType >::solve	(	const SparseBlockMatrix< MatrixType > &	A,
		double *	x,
		double *	b
	)

inlinevirtual

Assumes that A is the same matrix for several calls. Among other assumptions, the non-zero pattern does not change! If the matrix changes call init() before. solve system Ax = b, x and b have to allocated beforehand!!

Implements g2o::LinearSolver< MatrixType >.

Definition at line 62 of file linear_solver_cholmod.h.

                                                                           {
    double t;
    bool cholState = computeCholmodFactor(A, t);
    if (!cholState) return false;
 
    _cholmod.solve(x, b);
 
    G2OBatchStatistics* globalStats = G2OBatchStatistics::globalStats();
    if (globalStats) {
      globalStats->timeNumericDecomposition = get_monotonic_time() - t;
      globalStats->choleskyNNZ = _cholmod.choleskyNz();
    }
 
    return true;
  }

References g2o::LinearSolverCholmod< MatrixType >::_cholmod, g2o::G2OBatchStatistics::choleskyNNZ, g2o::cholmod::Cholmod::choleskyNz(), g2o::LinearSolverCholmod< MatrixType >::computeCholmodFactor(), g2o::get_monotonic_time(), g2o::G2OBatchStatistics::globalStats(), g2o::cholmod::Cholmod::solve(), and g2o::G2OBatchStatistics::timeNumericDecomposition.

◆ solveBlocks_impl()

template<typename MatrixType >

bool g2o::LinearSolverCholmod< MatrixType >::solveBlocks_impl	(	const SparseBlockMatrix< MatrixType > &	A,
		std::function< void(MarginalCovarianceCholesky &)>	compute
	)

inlineprotectedvirtual

Implements g2o::LinearSolverCCS< MatrixType >.

Definition at line 190 of file linear_solver_cholmod.h.

                                                              {
    double t;
    bool cholState = computeCholmodFactor(A, t);
    if (!cholState) return false;
 
    // convert the factorization to LL, simplical, packed, monotonic
    int change_status = _cholmod.simplifyFactor();
    if (!change_status) return false;
 
    cholmod::Cholmod::FactorView cholmodFactor = _cholmod.factor();
    cholmod::Cholmod::SparseView cholmodSparse = _cholmod.sparseView();
 
    // invert the permutation
    int* p = cholmodFactor.perm;
    VectorXI pinv(cholmodSparse.ncol);
    for (size_t i = 0; i < cholmodSparse.ncol; ++i) pinv(p[i]) = i;
 
    // compute the marginal covariance
    MarginalCovarianceCholesky mcc;
    mcc.setCholeskyFactor(cholmodSparse.ncol, cholmodFactor.p, cholmodFactor.i,
                          cholmodFactor.x, pinv.data());
    compute(mcc);
 
    G2OBatchStatistics* globalStats = G2OBatchStatistics::globalStats();
    if (globalStats) {
      globalStats->choleskyNNZ = _cholmod.choleskyNz();
    }
    return true;
  }

Member Data Documentation

◆ _blockPermutation

template<typename MatrixType >

VectorXI g2o::LinearSolverCholmod< MatrixType >::_blockPermutation

protected

Definition at line 89 of file linear_solver_cholmod.h.

Referenced by g2o::LinearSolverCholmod< MatrixType >::computeSymbolicDecomposition().

◆ _cholmod

template<typename MatrixType >

cholmod::Cholmod g2o::LinearSolverCholmod< MatrixType >::_cholmod

protected

Definition at line 87 of file linear_solver_cholmod.h.

Referenced by g2o::LinearSolverCholmod< MatrixType >::computeCholmodFactor(), g2o::LinearSolverCholmod< MatrixType >::computeSymbolicDecomposition(), g2o::LinearSolverCholmod< MatrixType >::fillCholmodExt(), g2o::LinearSolverCholmod< MatrixType >::freeCholdmodFactor(), g2o::LinearSolverCholmod< MatrixType >::saveMatrix(), g2o::LinearSolverCholmod< MatrixType >::solve(), and g2o::LinearSolverCholmod< MatrixType >::solveBlocks_impl().

◆ _matrixStructure

template<typename MatrixType >

MatrixStructure g2o::LinearSolverCholmod< MatrixType >::_matrixStructure

protected

Definition at line 88 of file linear_solver_cholmod.h.

Referenced by g2o::LinearSolverCholmod< MatrixType >::computeSymbolicDecomposition().

◆ _scalarPermutation

template<typename MatrixType >

VectorXI g2o::LinearSolverCholmod< MatrixType >::_scalarPermutation

protected

Definition at line 89 of file linear_solver_cholmod.h.

Referenced by g2o::LinearSolverCholmod< MatrixType >::computeSymbolicDecomposition().

The documentation for this class was generated from the following file:

/build/reproducible-path/g2o-0~20230806/g2o/solvers/cholmod/linear_solver_cholmod.h

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ LinearSolverCholmod() [1/2]

◆ LinearSolverCholmod() [2/2]

◆ ~LinearSolverCholmod()

Member Function Documentation

◆ computeCholmodFactor()

◆ computeSymbolicDecomposition()

◆ fillCholmodExt()

◆ freeCholdmodFactor()

◆ init()

◆ operator=()

◆ saveMatrix()

◆ solve()

◆ solveBlocks_impl()

Member Data Documentation

◆ _blockPermutation

◆ _cholmod

◆ _matrixStructure

◆ _scalarPermutation