VectorBase.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2018-2020 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2020 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2018-2020 Total, S.A
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */

#ifndef GEOSX_LINEARALGEBRA_INTERFACES_VECTORBASE_HPP_
#define GEOSX_LINEARALGEBRA_INTERFACES_VECTORBASE_HPP_

#include "linearAlgebra/common.hpp"
#include "mpiCommunications/MpiWrapper.hpp"
#include "rajaInterface/GEOS_RAJA_Interface.hpp"

namespace geosx
{

template< typename VECTOR >
class VectorBase
{
protected:

  using Vector = VECTOR;


  VectorBase()
    : m_closed( true )
  {}

  VectorBase( VectorBase const & ) = default;

  VectorBase( VectorBase && ) = default;

  VectorBase & operator=( VectorBase const & ) = default;

  VectorBase & operator=( VectorBase && ) = default;

  ~VectorBase() = default;



  inline bool closed() const { return m_closed; }

  virtual bool created() const = 0;

  inline bool ready() const { return created() && closed(); }



  virtual void createWithLocalSize( localIndex const localSize, MPI_Comm const & comm ) = 0;

  virtual void createWithGlobalSize( globalIndex const globalSize, MPI_Comm const & comm ) = 0;

  virtual void create( arrayView1d< real64 const > const & localValues, MPI_Comm const & comm ) = 0;



  virtual void open() = 0;

  virtual void close() = 0;

  virtual void reset()
  {
    m_closed = true;
  };



  virtual void set( globalIndex const globalRow,
                    real64 const value ) = 0;

  virtual void add( globalIndex const globalRow,
                    real64 const value ) = 0;

  virtual void set( globalIndex const * globalIndices,
                    real64 const * values,
                    localIndex const size ) = 0;

  virtual void add( globalIndex const * globalIndices,
                    real64 const * values,
                    localIndex const size ) = 0;

  virtual void set( arraySlice1d< globalIndex const > const & globalIndices,
                    arraySlice1d< real64 const > const & values ) = 0;


  virtual void add( arraySlice1d< globalIndex const > const & globalIndices,
                    arraySlice1d< real64 const > const & values ) = 0;

  virtual void set( real64 const value ) = 0;

  virtual void zero() = 0;

  virtual void rand( unsigned const seed = 1984 ) = 0;



  virtual void scale( real64 const scalingFactor ) = 0;

  virtual void reciprocal() = 0;

  virtual real64 dot( Vector const & vec ) const = 0;

  virtual void copy( Vector const & x ) = 0;

  virtual void axpy( real64 const alpha,
                     Vector const & x ) = 0;

  virtual void axpby( real64 const alpha,
                      Vector const & x,
                      real64 const beta ) = 0;

  virtual void pointwiseProduct( Vector const & x,
                                 Vector & y ) const = 0;

  virtual real64 norm1() const = 0;

  virtual real64 norm2() const = 0;

  virtual real64 normInf() const = 0;



  virtual globalIndex globalSize() const = 0;

  virtual localIndex localSize() const = 0;

  virtual globalIndex ilower() const = 0;

  virtual globalIndex iupper() const = 0;

  virtual real64 get( globalIndex globalRow ) const = 0;

  virtual void get( arraySlice1d< globalIndex const > const & globalIndices,
                    arraySlice1d< real64 > const & values ) const = 0;

  virtual localIndex getLocalRowID( globalIndex const globalRow ) const = 0;

  virtual globalIndex getGlobalRowID( localIndex const localRow ) const = 0;

  virtual real64 const * extractLocalVector() const = 0;

  virtual real64 * extractLocalVector() = 0;

  virtual void extract( arrayView1d< real64 > const & localVector ) const
  {
    real64 const * const data = extractLocalVector();
    forAll< parallelHostPolicy >( localSize(), [=] ( localIndex const k )
    {
      localVector[k] = data[k];
    } );
  }

  virtual MPI_Comm getComm() const = 0;



  virtual void print( std::ostream & os = std::cout ) const = 0;

  virtual void write( string const & filename,
                      LAIOutputFormat const format = LAIOutputFormat::MATRIX_MARKET ) const = 0;


  friend std::ostream & operator<<( std::ostream & os, Vector const & vec )
  {
    vec.print( os );
    return os;
  }

  bool m_closed;
};

} // namespace geosx

#endif //GEOSX_LINEARALGEBRA_INTERFACES_VECTORBASE_HPP_