Vector.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright (c) 2021.                                                        *
 * The Regents of the University of Michigan and DFT-EFE developers.          *
 *                                                                            *
 * This file is part of the DFT-EFE code.                                     *
 *                                                                            *
 * DFT-EFE is free software: you can redistribute it and/or modify            *
 *   it under the terms of the Lesser GNU General Public License as           *
 *   published by the Free Software Foundation, either version 3 of           *
 *   the License, or (at your option) any later version.                      *
 *                                                                            *
 * DFT-EFE is distributed in the hope that it will be useful, but             *
 *   WITHOUT ANY WARRANTY; without even the implied warranty                  *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                     *
 *   See the Lesser GNU General Public License for more details.              *
 *                                                                            *
 * You should have received a copy of the GNU Lesser General Public           *
 *   License at the top level of DFT-EFE distribution.  If not, see           *
 *   <https://www.gnu.org/licenses/>.                                         *
 ******************************************************************************/
 
/*
 * @author Bikash Kanungo
 */
 
 
#ifndef dftefeVector_h
#define dftefeVector_h
 
#include <utils/TypeConfig.h>
#include <utils/Defaults.h>
#include <utils/MemoryStorage.h>
#include <utils/MPITypes.h>
#include <utils/MPIPatternP2P.h>
#include <utils/MPICommunicatorP2P.h>
#include <linearAlgebra/VectorAttributes.h>
#include <linearAlgebra/LinAlgOpContext.h>
#include <linearAlgebra/BlasLapackTypedef.h>
#include <linearAlgebra/MultiVector.h>
#include <memory>
namespace dftefe
{
  namespace linearAlgebra
  {
    template <typename ValueType, dftefe::utils::MemorySpace memorySpace>
    class Vector : public MultiVector<ValueType, memorySpace>
    {
    public:
      //
      // typedefs
      //
      using Storage    = typename MultiVector<ValueType, memorySpace>::Storage;
      using value_type = typename Storage::value_type;
      using pointer    = typename Storage::pointer;
      using reference  = typename Storage::reference;
      using const_reference = typename Storage::const_reference;
      using iterator        = typename Storage::iterator;
      using const_iterator  = typename Storage::const_iterator;
 
      //
      // Forwarding the protected data members from the parent class
      // MultiVector. This is done to avoid using this->d_parentClassDataMember
      // or explicit qualification (ParentClass::d_parentClassMember)
      // and directly use d_parentClassDataMember.
      //
      using MultiVector<ValueType, memorySpace>::d_storage;
      using MultiVector<ValueType, memorySpace>::d_linAlgOpContext;
      using MultiVector<ValueType, memorySpace>::d_vectorAttributes;
      using MultiVector<ValueType, memorySpace>::d_localSize;
      using MultiVector<ValueType, memorySpace>::d_globalSize;
      using MultiVector<ValueType, memorySpace>::d_locallyOwnedSize;
      using MultiVector<ValueType, memorySpace>::d_ghostSize;
      using MultiVector<ValueType, memorySpace>::d_numVectors;
      using MultiVector<ValueType, memorySpace>::d_mpiCommunicatorP2P;
      using MultiVector<ValueType, memorySpace>::d_mpiPatternP2P;
 
 
    public:
      Vector() = default;
 
      ~Vector() = default;
 
      Vector(size_type                                     size,
             std::shared_ptr<LinAlgOpContext<memorySpace>> linAlgOpContext,
             ValueType initVal = utils::Types<ValueType>::zero);
 
      Vector(std::unique_ptr<typename Vector<ValueType, memorySpace>::Storage>
                                                           storage,
             std::shared_ptr<LinAlgOpContext<memorySpace>> linAlgOpContext);
 
      Vector(std::shared_ptr<const utils::mpi::MPIPatternP2P<memorySpace>>
                                                           mpiPatternP2P,
             std::shared_ptr<LinAlgOpContext<memorySpace>> linAlgOpContext,
             const ValueType initVal = utils::Types<ValueType>::zero);
 
      Vector(std::shared_ptr<const utils::mpi::MPIPatternP2P<memorySpace>>
                                                           mpiPatternP2P,
             std::shared_ptr<LinAlgOpContext<memorySpace>> linAlgOpContext,
             const ValueType                               min,
             const ValueType                               max);
 
      Vector(std::unique_ptr<typename Vector<ValueType, memorySpace>::Storage>
               &storage,
             std::shared_ptr<const utils::mpi::MPIPatternP2P<memorySpace>>
                                                           mpiPatternP2P,
             std::shared_ptr<LinAlgOpContext<memorySpace>> linAlgOpContext);
 
      Vector(
        const std::pair<global_size_type, global_size_type> locallyOwnedRange,
        const std::vector<dftefe::global_size_type> &       ghostIndices,
        const utils::mpi::MPIComm &                         mpiComm,
        std::shared_ptr<LinAlgOpContext<memorySpace>>       linAlgOpContext,
        const ValueType initVal = utils::Types<ValueType>::zero);
 
      Vector(
        const std::pair<global_size_type, global_size_type> locallyOwnedRange,
        const utils::mpi::MPIComm &                         mpiComm,
        std::shared_ptr<LinAlgOpContext<memorySpace>>       linAlgOpContext,
        const ValueType initVal = utils::Types<ValueType>::zero);
 
 
      Vector(const global_size_type                        globalSize,
             const utils::mpi::MPIComm &                   mpiComm,
             std::shared_ptr<LinAlgOpContext<memorySpace>> linAlgOpContext,
             const ValueType initVal = utils::Types<ValueType>::zero);
 
      Vector(const Vector<ValueType, memorySpace> &u);
 
      Vector(const Vector<ValueType, memorySpace> &u, ValueType initVal);
 
      Vector(Vector &&u) noexcept;
 
      Vector<ValueType, memorySpace> &
      operator=(const Vector<ValueType, memorySpace> &u);
 
      Vector<ValueType, memorySpace> &
      operator=(Vector<ValueType, memorySpace> &&u);
 
      double
      l2Norm() const;
 
      double
      lInfNorm() const;
    };
 
 
    template <typename ValueType1,
              typename ValueType2,
              utils::MemorySpace memorySpace>
    void
    dot(const Vector<ValueType1, memorySpace> &          u,
        const Vector<ValueType2, memorySpace> &          v,
        blasLapack::scalar_type<ValueType1, ValueType2> &dotProd,
        const blasLapack::ScalarOp &opU = blasLapack::ScalarOp::Identity,
        const blasLapack::ScalarOp &opV = blasLapack::ScalarOp::Identity);
 
  } // end of namespace linearAlgebra
} // end of namespace dftefe
#include <linearAlgebra/Vector.t.cpp>
#endif // dftefeVector_h