Intrepid2_DataTools.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//                           Intrepid2 Package
//
// Copyright 2007 NTESS and the Intrepid2 contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef Intrepid2_DataTools_h
#define Intrepid2_DataTools_h
 
#include "Intrepid2_Data.hpp"
 
namespace Intrepid2 {
 
class DataTools
{
public:
  template<class Scalar, class DeviceType>
  static void multiplyByCPWeights(Data<Scalar,DeviceType> &resultMatrixData, const Data<Scalar,DeviceType> &matrixDataIn, const Data<Scalar,DeviceType> &scalarDataIn)
  {
    const ordinal_type rank       = scalarDataIn.rank();
    const ordinal_type matrixRank = matrixDataIn.rank();
    auto extents                  = scalarDataIn.getExtents();
    auto variationTypes           = scalarDataIn.getVariationTypes();
    for (int r=rank; r<matrixRank; r++)
    {
      extents[r]        = matrixDataIn.extent_int(r);
      variationTypes[r] = CONSTANT;
    }
    
    auto scalarDataInExtended = scalarDataIn.shallowCopy(matrixRank, extents, variationTypes);
    resultMatrixData.storeInPlaceProduct(matrixDataIn,scalarDataInExtended);
  }
  
  template<class Scalar, class DeviceType>
  static Data<Scalar,DeviceType> multiplyByCPWeights(const Data<Scalar,DeviceType> &matrixDataIn, const Data<Scalar,DeviceType> &scalarDataIn)
  {
    const ordinal_type rank       = scalarDataIn.rank();
    const ordinal_type matrixRank = matrixDataIn.rank();
    auto extents                  = scalarDataIn.getExtents();
    auto variationTypes           = scalarDataIn.getVariationTypes();
    for (int r=rank; r<matrixRank; r++)
    {
      extents[r]        = matrixDataIn.extent_int(r);
      variationTypes[r] = CONSTANT;
    }
    
    auto scalarDataInExtended = scalarDataIn.shallowCopy(matrixRank, extents, variationTypes);
    
    auto result = Data<Scalar,DeviceType>::allocateInPlaceCombinationResult(scalarDataInExtended, matrixDataIn);
    
    result.storeInPlaceProduct(matrixDataIn,scalarDataInExtended);
    return result;
  }
  
  template<class Scalar, class DeviceType>
  static Data<Scalar,DeviceType> transposeMatrix(const Data<Scalar,DeviceType> &matrixDataIn)
  {
    // A direct construction of the transpose could be more efficient, but here we take advantage of existing
    // implementations within the Data class supporting matrix-matrix multiplication.  We construct an identity
    // matrix, and left-multiply this by the transpose of the input matrix.
    const ordinal_type rank = matrixDataIn.rank();
    auto extents            = matrixDataIn.getExtents();
    auto variationTypes     = matrixDataIn.getVariationTypes();
    const auto D1           = extents[rank-2];
    
    extents[rank-2]        = D1;
    extents[rank-1]        = D1;
    variationTypes[rank-2] = BLOCK_PLUS_DIAGONAL;
    variationTypes[rank-1] = BLOCK_PLUS_DIAGONAL;
    
    Kokkos::View<Scalar*,DeviceType> identityUnderlyingView("Intrepid2::DataTools::transposeMatrix() - identity view",D1);
    Kokkos::deep_copy(identityUnderlyingView, 1.0);
    Data<Scalar,DeviceType> identityData(identityUnderlyingView,extents,variationTypes);
    
    auto result = Data<Scalar,DeviceType>::allocateMatMatResult(true, matrixDataIn, false, identityData);
    result.storeMatMat(true, matrixDataIn, false, identityData);
    
    return result;
  }
};
}
 
#endif /* Intrepid2_DataTools_h */