QuadratureValuesContainer.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 dftefeQuadratureValuesContainer_h
#define dftefeQuadratureValuesContainer_h
 
#include <utils/TypeConfig.h>
#include <utils/MemorySpaceType.h>
#include <utils/MemoryStorage.h>
#include <linearAlgebra/LinAlgOpContext.h>
#include <quadrature/QuadratureRuleContainer.h>
namespace dftefe
{
  namespace quadrature
  {
    template <typename ValueType, utils::MemorySpace memorySpace>
    class QuadratureValuesContainer
    {
    public:
      using Storage = dftefe::utils::MemoryStorage<ValueType, memorySpace>;
      using SizeTypeVector = utils::MemoryStorage<size_type, memorySpace>;
      using pointer =
        typename dftefe::utils::MemoryStorage<ValueType, memorySpace>::pointer;
      using reference =
        typename dftefe::utils::MemoryStorage<ValueType,
                                              memorySpace>::reference;
      using const_reference =
        typename dftefe::utils::MemoryStorage<ValueType,
                                              memorySpace>::const_reference;
      using iterator =
        typename dftefe::utils::MemoryStorage<ValueType, memorySpace>::iterator;
      using const_iterator =
        typename dftefe::utils::MemoryStorage<ValueType,
                                              memorySpace>::const_iterator;
 
    public:
      QuadratureValuesContainer();
      QuadratureValuesContainer(
        std::shared_ptr<const QuadratureRuleContainer> quadratureRuleContainer,
        const size_type                                numberComponents,
        // const std::pair<size_type, size_type>          cellRange,
        const ValueType initVal = ValueType());
 
      ~QuadratureValuesContainer() = default;
 
      void
      reinit(
        std::shared_ptr<const QuadratureRuleContainer> quadratureRuleContainer,
        const size_type                                numberComponents,
        const ValueType                                initVal = ValueType());
 
      QuadratureValuesContainer(const QuadratureValuesContainer &u);
      QuadratureValuesContainer(QuadratureValuesContainer &&u);
 
      QuadratureValuesContainer &
      operator=(const QuadratureValuesContainer &rhs);
 
      QuadratureValuesContainer &
      operator=(QuadratureValuesContainer &&rhs);
 
      template <utils::MemorySpace memorySpaceSrc>
      void
      setCellValues(const size_type cellId, const ValueType *values);
 
      template <utils::MemorySpace memorySpaceSrc>
      void
      setCellQuadValues(const size_type  cellId,
                        const size_type  quadId,
                        const ValueType *values);
 
      void
      setValue(const ValueType value);
 
      template <utils::MemorySpace memorySpaceDst>
      void
      getCellValues(const size_type cellId, ValueType *values) const;
 
      template <utils::MemorySpace memorySpaceDst>
      void
      getCellQuadValues(const size_type cellId,
                        const size_type quadId,
                        ValueType *     values) const;
 
      std::shared_ptr<const QuadratureRuleContainer>
      getQuadratureRuleContainer() const;
 
      size_type
      getNumberComponents() const;
 
      size_type
      nCells() const;
      size_type
      nQuadraturePoints() const;
      size_type
      nEntries() const;
 
      size_type
      nCellQuadraturePoints(const size_type cellId) const;
      size_type
      nCellEntries(const size_type cellId) const;
      size_type
      cellStartId(const size_type cellId) const;
 
      const SizeTypeVector &
      getCellStartIds() const;
      const SizeTypeVector &
      getNumberCellEntries() const;
 
      iterator
      begin();
 
      const_iterator
      begin() const;
 
      iterator
      end();
 
      const_iterator
      end() const;
 
      iterator
      begin(const size_type cellId);
 
      const_iterator
      begin(const size_type cellId) const;
 
      iterator
      end(const size_type cellId);
 
      const_iterator
      end(const size_type cellId) const;
 
      ValueType *
      data();
 
      const ValueType *
      data() const;
 
      // ValueType
      // dotProduct() const;
 
    private:
      size_type                                      d_numberComponents;
      SizeTypeVector                                 d_cellStartIds;
      SizeTypeVector                                 d_numCellEntries;
      Storage                                        d_storage;
      std::shared_ptr<const QuadratureRuleContainer> d_quadratureRuleContainer;
    }; // end of QuadratureValuesContainer
 
 
    //
    // Helper functions
    //
 
    template <typename ValueType1,
              typename ValueType2,
              dftefe::utils::MemorySpace memorySpace>
    void
    add(linearAlgebra::blasLapack::scalar_type<ValueType1, ValueType2> a,
        const QuadratureValuesContainer<ValueType1, memorySpace> &     u,
        linearAlgebra::blasLapack::scalar_type<ValueType1, ValueType2> b,
        const QuadratureValuesContainer<ValueType2, memorySpace> &     v,
        QuadratureValuesContainer<
          linearAlgebra::blasLapack::scalar_type<ValueType1, ValueType2>,
          memorySpace> &                             w,
        linearAlgebra::LinAlgOpContext<memorySpace> &linAlgOpContext);
 
    template <typename ValueType, dftefe::utils::MemorySpace memorySpace>
    void
    add(ValueType                                                a,
        const QuadratureValuesContainer<ValueType, memorySpace> &u,
        ValueType                                                b,
        QuadratureValuesContainer<ValueType, memorySpace> &      v,
        linearAlgebra::LinAlgOpContext<memorySpace> &linAlgOpContext);
 
    template <typename ValueType1,
              typename ValueType2,
              dftefe::utils::MemorySpace memorySpace>
    void
    scale(ValueType1                                                alpha,
          const QuadratureValuesContainer<ValueType2, memorySpace> &u,
          QuadratureValuesContainer<
            linearAlgebra::blasLapack::scalar_type<ValueType1, ValueType2>,
            memorySpace> &                             w,
          linearAlgebra::LinAlgOpContext<memorySpace> &linAlgOpContext);
 
    template <typename ValueType, dftefe::utils::MemorySpace memorySpace>
    void
    scale(ValueType                                          alpha,
          QuadratureValuesContainer<ValueType, memorySpace> &u,
          linearAlgebra::LinAlgOpContext<memorySpace> &      linAlgOpContext);
 
  } // end of namespace quadrature
} // end of namespace dftefe
#include <quadrature/QuadratureValuesContainer.t.cpp>
#endif // dftefeQuadratureValuesContainer_h