EnrichmentClassicalInterfaceSpherical.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 dftefeEnrichmentClassicalInterfaceSpherical_h
#define dftefeEnrichmentClassicalInterfaceSpherical_h
 
#include <utils/Point.h>
#include <utils/TypeConfig.h>
#include <vector>
#include <string>
#include <unordered_map>
#include <utils/OptimizedIndexSet.h>
#include <utils/MPITypes.h>
#include <utils/MPIWrapper.h>
#include <memory>
#include <utils/TypeConfig.h>
#include <utils/MemorySpaceType.h>
#include <basis/FEBasisManager.h>
#include <basis/FEBasisDofHandler.h>
#include <basis/FEBasisDataStorage.h>
#include <basis/CFEOverlapOperatorContext.h>
#include <basis/FEBasisOperations.h>
#include <basis/AtomIdsPartition.h>
#include <atoms/AtomSphericalDataContainer.h>
#include <basis/EnrichmentIdsPartition.h>
#include <basis/TriangulationBase.h>
#include <linearAlgebra/LinAlgOpContext.h>
#include <basis/Defaults.h>
 
namespace dftefe
{
  namespace basis
  {
    template <typename ValueTypeBasisData,
              utils::MemorySpace memorySpace,
              size_type          dim>
    class EnrichmentClassicalInterfaceSpherical
    {
    public:
      EnrichmentClassicalInterfaceSpherical(
        std::shared_ptr<
          const FEBasisDataStorage<ValueTypeBasisData, memorySpace>>
          cfeBasisDataStorageOverlapMatrix,
        std::shared_ptr<
          const FEBasisDataStorage<ValueTypeBasisData, memorySpace>>
          cfeBasisDataStorageRhs,
        std::shared_ptr<const atoms::AtomSphericalDataContainer>
                                         atomSphericalDataContainer,
        const double                     atomPartitionTolerance,
        const std::vector<std::string> & atomSymbolVec,
        const std::vector<utils::Point> &atomCoordinatesVec,
        const std::string                fieldName,
        std::shared_ptr<linearAlgebra::LinAlgOpContext<memorySpace>>
                                   linAlgOpContext,
        const utils::mpi::MPIComm &comm,
        const size_type            enrichmentBatchSize =
          ECIDefaults::ENRICHMENT_BATCH_SIZE,
        const size_type cellBlockSize =
          BasisDataStorageDefaults<memorySpace>::CELL_BATCH_SIZE);
 
      EnrichmentClassicalInterfaceSpherical(
        std::shared_ptr<const TriangulationBase> triangulation,
        size_type                                feOrder,
        std::shared_ptr<const atoms::AtomSphericalDataContainer>
                                         atomSphericalDataContainer,
        const double                     atomPartitionTolerance,
        const std::vector<std::string> & atomSymbolVec,
        const std::vector<utils::Point> &atomCoordinatesVec,
        const std::string                fieldName,
        const utils::mpi::MPIComm &      comm);
 
      ~EnrichmentClassicalInterfaceSpherical();
 
      std::shared_ptr<const atoms::AtomSphericalDataContainer>
      getAtomSphericalDataContainer() const;
 
      std::shared_ptr<const EnrichmentIdsPartition<dim>>
      getEnrichmentIdsPartition() const;
 
      std::shared_ptr<const AtomIdsPartition<dim>>
      getAtomIdsPartition() const;
 
      std::shared_ptr<const BasisManager<ValueTypeBasisData, memorySpace>>
      getCFEBasisManager() const;
 
      std::vector<ValueTypeBasisData>
      getClassicalComponentCoeffsInCellOEFE(const size_type cellIndex) const;
 
      std::vector<ValueTypeBasisData>
      getClassicalComponentCoeffsInAllCellsOEFE() const;
 
      std::shared_ptr<linearAlgebra::LinAlgOpContext<memorySpace>>
      getLinAlgOpContext() const;
 
      bool
      isOrthogonalized() const;
 
      std::vector<std::string>
      getAtomSymbolVec() const;
 
      std::vector<utils::Point>
      getAtomCoordinatesVec() const;
 
      std::string
      getFieldName() const;
 
      std::shared_ptr<const TriangulationBase>
      getTriangulation() const;
 
      // no p refinement assumed
      size_type
      getFEOrder() const;
 
      global_size_type
      getEnrichmentId(size_type cellId, size_type enrichmentCellLocalId) const;
 
      size_type
      getEnrichmentLocalId(global_size_type enrichmentId) const;
 
      size_type
      getEnrichmentLocalId(size_type cellId,
                           size_type enrichmentCellLocalId) const;
 
      std::vector<double>
      getEnrichmentValue(const size_type                          cellId,
                         const std::vector<dftefe::utils::Point> &points) const;
 
      std::vector<double>
      getEnrichmentDerivative(
        const size_type                          cellId,
        const std::vector<dftefe::utils::Point> &points) const;
 
      std::vector<double>
      getEnrichmentHessian(
        const size_type                          cellId,
        const std::vector<dftefe::utils::Point> &points) const;
 
      void
      getEnrichmentDataInAllCellsAtQuadPts(
        bool                                       storeValues,
        bool                                       storeGradients,
        const quadrature::QuadratureRuleContainer &quadRuleContainer,
        double *basisEnrichQuadStorageStartPtr,
        double *basisGradientEnrichQuadStorageStartPtr,
        linearAlgebra::LinAlgOpContext<memorySpace> &linAlgOpContext,
        const size_type                              enrichBlock = 500) const;
 
      void
      getEnrichmentValuesInCellRangeAtQuadPts(
        const quadrature::QuadratureRuleContainer &  quadRuleContainer,
        double *                                     basisEnrichQuadStoragePtr,
        linearAlgebra::LinAlgOpContext<memorySpace> &linAlgOpContext,
        const std::pair<size_type, size_type>        cellRange) const;
 
      void
      getEnrichmentGradientsInCellRangeAtQuadPts(
        const quadrature::QuadratureRuleContainer &quadRuleContainer,
        double *basisGradientEnrichQuadStoragePtr,
        linearAlgebra::LinAlgOpContext<memorySpace> &linAlgOpContext,
        const std::pair<size_type, size_type>        cellRange) const;
 
    private:
      const std::unordered_map<global_size_type,
                               utils::OptimizedIndexSet<size_type>> &
      getClassicalComponentLocalIdsMap() const;
 
      const std::unordered_map<global_size_type,
                               std::vector<ValueTypeBasisData>> &
      getClassicalComponentCoeffMap() const;
 
      std::shared_ptr<const BasisDofHandler>
      getCFEBasisDofHandler() const;
 
      void
      getOverlappingEnrichmentInCellsAdditionalData();
 
      std::shared_ptr<EnrichmentIdsPartition<dim>> d_enrichmentIdsPartition;
      std::shared_ptr<const AtomIdsPartition<dim>> d_atomIdsPartition;
      std::shared_ptr<const atoms::AtomSphericalDataContainer>
                                               d_atomSphericalDataContainer;
      std::shared_ptr<const TriangulationBase> d_triangulation;
      bool                                     d_isOrthogonalized;
      std::shared_ptr<
        const FEBasisDofHandler<ValueTypeBasisData, memorySpace, dim>>
        d_cfeBasisDofHandler;
      std::shared_ptr<const FEBasisManager<ValueTypeBasisData,
                                           ValueTypeBasisData,
                                           memorySpace,
                                           dim>>
                                      d_cfeBasisManager;
      const std::vector<std::string>  d_atomSymbolVec;
      const std::vector<utils::Point> d_atomCoordinatesVec;
      const std::string               d_fieldName;
      std::vector<std::vector<global_size_type>>
        d_overlappingEnrichmentIdsInCells;
 
      std::unordered_map<global_size_type, utils::OptimizedIndexSet<size_type>>
        d_enrichmentIdToClassicalLocalIdMap;
 
      std::unordered_map<global_size_type, std::vector<ValueTypeBasisData>>
        d_enrichmentIdToInterfaceCoeffMap;
 
      std::shared_ptr<linearAlgebra::LinAlgOpContext<memorySpace>>
        d_linAlgOpContext;
 
      size_type d_feOrder;
 
      const utils::mpi::MPIComm d_comm;
 
      size_type d_enrichBatchSize;
      size_type d_cellBlockSize;
 
      utils::MemoryStorage<double, memorySpace> d_originMemSpace;
      std::vector<size_type>                    d_numEnrichInAllCells;
      atoms::SphericalDataNumerical::Func<memorySpace>
        *d_sphericalDataNumericalFuncPtrVec;
 
    }; // end of class
  }    // end of namespace basis
} // end of namespace dftefe
#include <basis/EnrichmentClassicalInterfaceSpherical.t.cpp>
#endif // dftefeEnrichmentClassicalInterfaceSpherical_h