DistributedVector.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 <cstring>
#include <map>
#include <memory>
 
// Bug with PETSc and VTK: need to put this file using macro HZ first
#include <vtkPointLocator.h>
 
#ifdef CEPS_USE_PETSC
  #include <petscvec.h>
// We will manipulate a PETSc vector
using PetscVector = Vec;
#endif  // CEPS_USE_PETSC
 
#include "common/CepsCommon.hpp"
#include "linearAlgebra/DistributedMatrix.hpp"
 
class DistributedVector
{
 
  public:
 
    friend class DistributedMatrix;
  
    DistributedVector();
  
    DistributedVector(const DistributedVector& v);
  
    DistributedVector&
    operator=(const DistributedVector& v);
  
    DistributedVector(CepsInt M, CepsInt m);
  
    DistributedVector(
      DistributedVector& templateVector,
      CepsBool           copyValues,
      CepsBool           isSequential = false
    );
  
    DistributedVector(
      std::shared_ptr<DistributedVector> templateVector,
      CepsBool                           copyValues,
      CepsBool                           isSequential = false
    );
  
    DistributedVector(DMatPtr mat, CepsGlobalIndex row);
  
    virtual ~DistributedVector();
  
    inline CepsString
    getUnit() const;
  
    inline void
    setUnit(const CepsString& u);
  
    CepsMathScalar*
    localData();
  
    void
    setSize(CepsInt M, CepsInt m);
  
    void
    getSize(CepsInt* globalSize) const;
  
    CepsInt
    getSize() const;
  
    void
    getLocalSize(CepsInt* localSize) const;
  
    CepsInt
    getLocalSize() const;
  
    void
    getLocalRange(CepsGlobalIndex* lo, CepsGlobalIndex* hi) const;
  
    virtual void
    getLocalData();
  
    virtual void
    releaseLocalData();
  
    const PetscVector&
    getVector() const;
  
    void
    setValue(CepsMathScalar value, CepsGlobalIndex i);
  
    void
    addValue(CepsMathScalar value, CepsGlobalIndex i);
  
    void
    ignoreOffProcEntries(CepsBool ignore);
  
    void
    setValues(const CepsMathScalar* values, CepsInt n, const CepsGlobalIndex* indices);
  
    void
    setValuesLocal(DistributedVector& values, CepsInt n, const CepsGlobalIndex* indices = nullptr);
  
    void
    setValuesLocal(
      const CepsMathScalar*  values,
      CepsInt                n,
      const CepsGlobalIndex* indices = nullptr
    );
  
    void
    setValuesLocal(
      const CepsVector<CepsMathScalar>&  values,
      const CepsVector<CepsGlobalIndex>& indices
    );
  
    void
    addValues(const CepsMathScalar* values, CepsInt n, const CepsGlobalIndex* indices);
  
    void
    addValuesLocal(DistributedVector& values, CepsInt n, const CepsGlobalIndex* indices = nullptr);
  
    void
    addValuesLocal(
      const CepsMathScalar*  values,
      CepsInt                n,
      const CepsGlobalIndex* indices = nullptr
    );
  
    virtual void
    getValues(CepsMathScalar* values, CepsInt n, const CepsGlobalIndex* indices);
  
    void
    addSubVector(const CepsMathDynamic1D& subVector, const CepsVector<CepsGlobalIndex>& rowIndices);
  
    void
    insertSubVector(
      const CepsMathDynamic1D&           subVector,
      const CepsVector<CepsGlobalIndex>& rowIndices
    );
  
    CepsVector<CepsMathScalar>
    getSubVector(const CepsVector<CepsGlobalIndex>& rowIndices);
  
    void
    zero ();
  
    void
    fill(CepsMathScalar value);
  
    void
    duplicate(DistributedVector& dest, CepsBool copyValues) const;
  
    void
    beginAssembly();
  
    void
    endAssembly();
  
    void
    finalize();
  
    CepsBool
    isAssembled() const;
  
    CepsBool
    sameSize(const DistributedVector& vec) const;
  
    CepsBool
    sameLocalRange(const DistributedVector& vec) const;
  
    CepsBool
    equals(const DistributedVector& vec, CepsMathScalar errorFactor = 1.0) const;
  
    CepsBool
    approxEquals(const DistributedVector& vec, CepsMathScalar epsilon) const;
 
    void
    checkNanOrInf(CepsString message="");
 
    void
    add(const DistributedVector& x);
  
    void
    addScaled(const DistributedVector& x, CepsMathScalar alpha);
   
    virtual void
    scale(CepsMathScalar alpha);
  
    virtual void 
    pointWiseScale(const DistributedVector& x, CepsBool divide=false);
  
    virtual void
    mult(const DistributedMatrix& A, const DistributedVector& x);
  
    virtual void
    abs();
  
    CepsMathScalar
    dot(DistributedVector& x);
  
    CepsMathScalar
    lInfNorm() const;
  
    CepsMathScalar
    l1Norm() const;
  
    CepsMathScalar
    l2Norm() const;
  
    void
    view() const;
  
    virtual CepsMathScalar&
    operator[](CepsGlobalIndex globalIndex);
  
    virtual CepsMathScalar
    operator[](CepsGlobalIndex globalIndex) const;
  
    DistributedVector&
    operator+=(const DistributedVector& v);
  
    DistributedVector&
    operator+=(const CepsMathScalar& scalar);
  
    DistributedVector&
    operator-=(const DistributedVector& v);
  
    DistributedVector&
    operator-=(const CepsMathScalar& scalar);
  
    DistributedVector&
    operator*=(const CepsMathScalar& scalar);
  
    void
    fillFromVector(const CepsVector<CepsMathScalar>& data);
  
    friend class TestDistributedVector;
  
  
  protected:
 
    void
    checkAndSetSizes(CepsInt gSize, CepsInt lSize);
  
    void
    createEmptyVector();
  
 
  protected:
  
    CepsString      m_unit;        
    PetscVector     m_v;           
    CepsGlobalIndex m_lo;          
    CepsGlobalIndex m_hi;          
    CepsInt         m_globalSize;  
    CepsInt         m_localSize;   
  
    CepsMathScalar *m_localData;
  
    CepsBool m_mayReadData;
    CepsBool m_isAssembled;  
  
    #ifdef PROFILING_VECTOR
    CepsMathScalar m_totalAssembly;
    CepsMathScalar m_tickAssembly;
    #endif
  
    CepsBool m_initialized;  
    CepsBool m_vecCreated;   
 
};
 
using DVecPtr = std::shared_ptr<DistributedVector>;
 
DistributedVector
operator+(const DistributedVector& lhs, const DistributedVector& rhs);
 
DistributedVector
operator+(const DistributedVector& lhs, const CepsMathScalar& scalar);
 
DistributedVector
operator-(const DistributedVector& lhs, const DistributedVector& rhs);
 
DistributedVector
operator-(const DistributedVector& lhs, const CepsMathScalar& scalar);
 
DistributedVector
operator*(const DistributedVector& lhs, const CepsMathScalar& scalar);
 
DistributedVector
operator*(const CepsMathScalar& scalar, const DistributedVector& rhs);
 
DistributedVector
operator*(const DistributedMatrix& A, const DistributedVector& x);