DistributedMatrix.hpp

Go to the documentation of this file.

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   This file is part of CEPS.
 
   CEPS is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
   CEPS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with CEPS (see file LICENSE at root of project).
   If not, see <https://www.gnu.org/licenses/>.
 
 
   Copyright 2019-2024 Inria, Universite de Bordeaux
 
   Authors, in alphabetical order:
 
     Pierre-Elliott BECUE, Florian CARO, Yves COUDIERE(*), Andjela DAVIDOVIC, 
     Charlie DOUANLA-LONTSI, Marc FUENTES, Mehdi JUHOOR, Michael LEGUEBE(*), 
     Pauline MIGERDITICHAN, Valentin PANNETIER(*), Nejib ZEMZEMI.
     * : currently active authors
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#pragma once
 
// #include "CepsConfig.h"
#include <memory>
 
#include "common/CepsCommon.hpp"
 
#ifdef CEPS_USE_PETSC
  #include <petscmat.h>
  #include <petscsys.h>
// We will manipulate a PETSc matrix
using PetscMatrix = Mat;
#endif  // CEPS_USE_PETSC
 
#include <Eigen/Dense>
#include <iostream>
 
class DistributedVector;
 
class DistributedMatrix
{
public:
  DistributedMatrix ();
 
  DistributedMatrix (CepsInt M, CepsInt N, CepsInt m, CepsInt n);
 
  explicit DistributedMatrix (const DistributedMatrix &templateMatrix, CepsBool copyValues = false);
 
  explicit DistributedMatrix (const CepsString &file);
 
  ~DistributedMatrix ();
 
  void
  ignoreOffProcEntries (CepsBool flag);
 
  void
  setSymmetric (CepsBool flag = true);
 
  void
  setSize (CepsInt M, CepsInt N, CepsInt m, CepsInt n);
 
  void
  setNonZeroStructure (const CepsInt d_nnz[], const CepsInt o_nnz[]);
 
  void
  setNonZeroStructure (CepsInt d_nz, CepsInt o_nz);
 
  void
  setValue (CepsMathScalar value, CepsGlobalIndex i, CepsGlobalIndex j);
 
  void
  addValue (CepsMathScalar value, CepsGlobalIndex i, CepsGlobalIndex j);
 
  void
  getValues (
    CepsMathScalar        *values,
    CepsInt                nbRows,
    CepsInt                nbColumns,
    const CepsGlobalIndex *rowIndices,
    const CepsGlobalIndex *columnIndices
  );
 
  void
  setValues (
    const CepsMathScalar  *values,
    CepsInt                nbRows,
    CepsInt                nbColumns,
    const CepsGlobalIndex *rowIndices,
    const CepsGlobalIndex *columnIndices
  );
 
  void
  addValues (
    const CepsMathScalar  *values,
    CepsInt                nbRows,
    CepsInt                nbColumns,
    const CepsGlobalIndex *rowIndices,
    const CepsGlobalIndex *columnIndices
  );
 
  void
  addSubMatrix (
    const CepsMathDynamic2D           &subMat,
    const CepsVector<CepsGlobalIndex> &indicesI,
    const CepsVector<CepsGlobalIndex> &indicesJ
  );
 
  void
  getSubMatrix (
    const CepsVector<CepsGlobalIndex> &indicesI,
    const CepsVector<CepsGlobalIndex> &indicesJ,
    CepsMathDynamic2D                 &subMat
  );
 
  void
  zeroRowsAndColumns (CepsInt nbRows, CepsGlobalIndex *rows, CepsMathScalar diagonalValue = 1.0);
 
  void
  zeroRows (CepsInt nbRows, CepsGlobalIndex *rows, CepsMathScalar diagonalValue = 1.0);
 
  void
  zero ();
 
  void
  identity ();
 
  void
  add (DistributedMatrix &X, CepsMathScalar a, CepsBool sameNonZeroStructure = true);
 
  CepsMathScalar
  lInfNorm () const;
 
  CepsMathScalar
  l1Norm () const;
 
  CepsMathScalar
  l2Norm () const;
 
  void
  copy (DistributedMatrix &A) const;
 
  void
  duplicate (DistributedMatrix &dest, CepsBool copyValues) const;
 
  void
  getSize (CepsInt *M, CepsInt *N) const;
 
  void
  getLocalSize (CepsInt *m, CepsInt *n) const;
 
  void
  getLocalRange (CepsGlobalIndex *lo, CepsGlobalIndex *hi) const;
 
  void
  getLocalRow (
    const CepsMathScalar  **values,
    CepsGlobalIndex         row,
    CepsInt                *nbNonZero,
    const CepsGlobalIndex **nonZeroCols
  ) const;
 
  void
  releaseLocalRow (
    const CepsMathScalar  **values,
    CepsGlobalIndex         row,
    CepsInt                *nbNonZero,
    const CepsGlobalIndex **nonZeroCols
  );
 
  void
  getLocalRow (CepsVector<CepsMathScalar> &rowValues, CepsGlobalIndex row);
 
  void
  getEntireLocalRow (CepsVector<CepsMathScalar> &rowValues, CepsGlobalIndex row) const;
 
  void
  getColumnAsDistributedVector (DistributedVector &v, CepsGlobalIndex column) const;
 
  void
  setColumnAsDistributedVector (DistributedVector &v, CepsGlobalIndex column);
 
  void 
  getDiagonalAsDistributedVector(DistributedVector &v) const;
 
  void 
  setDiagonalAsDistributedVector(DistributedVector &v);
 
 
  void 
  getDiagonalFootPrintAsDistributedVector(DistributedVector &v, CepsReal epsilon = 1E-12) const;
 
  const PetscMatrix &
  getMatrix () const;
 
  void
  save (const CepsString &filename);
 
  void
  load (const CepsString &filename);
 
  void
  beginAssembly ();
 
  void
  endAssembly ();
 
  void
  finalize ();
 
  void
  flush ();
 
  CepsBool
  isAssembled () const;
 
  void
  assertAssembled(CepsString info="") const;
 
  CepsBool
  isSymmetric () const;
 
  void
  checkProperlySet () const;
 
  void
  view () const;
 
  DistributedMatrix &
  operator*= (const CepsMathScalar &scalar);
 
  friend class TestDistributedMatrix;
 
private:
  PetscMatrix     m_A;            
  CepsGlobalIndex m_lo;           
  CepsGlobalIndex m_hi;           
  CepsBool        m_properlySet;  
};
 
using DMatPtr = std::shared_ptr<DistributedMatrix>;