MultiVectorOps.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 Avirup Sircar
 */
 
#ifndef dftefeMultiVectorOps_h
#define dftefeMultiVectorOps_h
 
#include <utils/MemorySpaceType.h>
#include <utils/MemoryStorage.h>
#include <linearAlgebra/BlasLapackTypedef.h>
#include <linearAlgebra/MultiVector.h>
#include <linearAlgebra/MultiVectorProductSpace.h>
#include <linearAlgebra/MultiVectorProductSpaceBlocked.h>
#include <linearAlgebra/OperatorContext.h>
#include <linearAlgebra/ElpaScalapackManager.h>
#include <vector>
 
namespace dftefe
{
  namespace linearAlgebra
  {
    class MultiVectorOps
    {
    public:
      // -----------------------------------------------------------------------
      // project
      // -----------------------------------------------------------------------
 
      template <typename ValueTypeOperator,
                typename ValueTypeOperand,
                utils::MemorySpace memorySpace>
      static void
      project(
        const OperatorContext<ValueTypeOperator, ValueTypeOperand, memorySpace>
          &                                                               Op,
        MultiVectorProductSpaceBlocked<ValueTypeOperand, memorySpace> &   X,
        std::vector<ScaLAPACKMatrix<
          blasLapack::scalar_type<ValueTypeOperator, ValueTypeOperand>>> &Ps,
        const ElpaScalapackManager &                                      elpa,
        std::shared_ptr<MultiVector<
          blasLapack::scalar_type<ValueTypeOperator, ValueTypeOperand>,
          memorySpace>> &scratchXin,
        std::shared_ptr<MultiVector<
          blasLapack::scalar_type<ValueTypeOperator, ValueTypeOperand>,
          memorySpace>> &scratchXout,
        std::shared_ptr<MultiVector<
          blasLapack::scalar_type<ValueTypeOperator, ValueTypeOperand>,
          memorySpace>> &scratchXinSmall,
        std::shared_ptr<MultiVector<
          blasLapack::scalar_type<ValueTypeOperator, ValueTypeOperand>,
          memorySpace>> &scratchXoutSmall);
 
      template <typename ValueTypeOperator,
                typename ValueTypeOperand,
                utils::MemorySpace memorySpace>
      static void
      project(
        const OperatorContext<ValueTypeOperator, ValueTypeOperand, memorySpace>
          &                                                     Op,
        MultiVectorProductSpace<ValueTypeOperand, memorySpace> &X,
        ScaLAPACKMatrix<
          blasLapack::scalar_type<ValueTypeOperator, ValueTypeOperand>> &P,
        const ElpaScalapackManager &                                     elpa,
        std::shared_ptr<MultiVector<
          blasLapack::scalar_type<ValueTypeOperator, ValueTypeOperand>,
          memorySpace>> &scratchXin,
        std::shared_ptr<MultiVector<
          blasLapack::scalar_type<ValueTypeOperator, ValueTypeOperand>,
          memorySpace>> &scratchXout,
        std::shared_ptr<MultiVector<
          blasLapack::scalar_type<ValueTypeOperator, ValueTypeOperand>,
          memorySpace>> &scratchXinSmall,
        std::shared_ptr<MultiVector<
          blasLapack::scalar_type<ValueTypeOperator, ValueTypeOperand>,
          memorySpace>> &scratchXoutSmall);
 
      // -----------------------------------------------------------------------
      // rotate
      // -----------------------------------------------------------------------
 
      template <typename ValueType, utils::MemorySpace memorySpace>
      static void
      rotate(MultiVectorProductSpaceBlocked<ValueType, memorySpace> &X,
             const std::vector<ScaLAPACKMatrix<ValueType>> &         Qs,
             const ElpaScalapackManager &                            elpa);
 
      template <typename ValueType, utils::MemorySpace memorySpace>
      static void
      rotate(MultiVectorProductSpace<ValueType, memorySpace> &X,
             const ScaLAPACKMatrix<ValueType> &               Q,
             const ElpaScalapackManager &                     elpa);
 
      // -----------------------------------------------------------------------
      // copyToBatch / copyFromBatch
      // -----------------------------------------------------------------------
 
      // Gather numVecBatch orbitals starting at srcStart for every spin channel
      // into a flat MultiVector batch (Xbatch columns: spin-0, then spin-1,
      // ...). Xbatch must have numSpaces * numVecBatch components. Two-type
      // template mirrors stridedBlockCopy<VT1,VT2>: X stores VT1, Xbatch stores
      // VT2 (typically VT1==VT2; differs inside projectImpl).
 
      template <typename ValueType1,
                typename ValueType2,
                utils::MemorySpace memorySpace>
      static void
      copyToBatch(const MultiVectorProductSpace<ValueType1, memorySpace> &X,
                  size_type                             srcStart,
                  size_type                             numVecBatch,
                  MultiVector<ValueType2, memorySpace> &Xbatch,
                  LinAlgOpContext<memorySpace> &        context);
 
      // Inverse of copyToBatch: scatter the batch back into the product-space
      // multivector at orbital positions [dstStart, dstStart+numVecBatch).
 
      template <typename ValueType1,
                typename ValueType2,
                utils::MemorySpace memorySpace>
      static void
      copyFromBatch(const MultiVector<ValueType1, memorySpace> &Ybatch,
                    size_type                                   dstStart,
                    size_type                                   numVecBatch,
                    MultiVectorProductSpace<ValueType2, memorySpace> &Y,
                    LinAlgOpContext<memorySpace> &                    context);
 
    }; // class MultiVectorOps
 
  } // namespace linearAlgebra
} // namespace dftefe
 
#include <linearAlgebra/MultiVectorOps.t.cpp>
#endif // dftefeMultiVectorOps_h