simpleassemblers.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2021-2024 The Ikarus Developers mueller@ibb.uni-stuttgart.de
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
 
#include <utility>
 
#include <Eigen/Core>
#include <Eigen/Sparse>
 
#include <ikarus/assembler/interface.hh>
#include <ikarus/finiteelements/ferequirements.hh>
 
namespace Ikarus {
template <typename FEC, typename DV>
class ScalarFlatAssembler : public ScalarAssembler<ScalarFlatAssembler<FEC, DV>, FEC, DV, double>,
                            public FlatAssemblerBase<FEC, DV>
{
protected:
  using Base = FlatAssemblerBase<FEC, DV>; 
  friend ScalarAssembler<ScalarFlatAssembler, FEC, DV, double>;
 
  using Base::Base;
 
public:
  using typename Base::Basis;
  using typename Base::DirichletValuesType;
  using typename Base::FEContainer;
  using typename Base::FERequirement;
  using typename Base::GlobalIndex;
  using typename ScalarAssembler<ScalarFlatAssembler, FEC, DV, double>::ScalarType;
 
protected:
  ScalarType& getScalarImpl(const FERequirement& feRequirements, ScalarAffordance affordance);
 
  ScalarType scal_{0.0};
};
 
#ifndef DOXYGEN
template <class T, class DirichletValuesType>
ScalarFlatAssembler(T&& fes, const DirichletValuesType& dirichletValues) -> ScalarFlatAssembler<T, DirichletValuesType>;
#endif
 
template <typename FEC, typename DV>
class VectorFlatAssembler : public ScalarFlatAssembler<FEC, DV>,
                            public VectorAssembler<VectorFlatAssembler<FEC, DV>, FEC, DV, Eigen::VectorXd>
{
protected:
  using Base = ScalarFlatAssembler<FEC, DV>; 
  friend VectorAssembler<VectorFlatAssembler, FEC, DV, Eigen::VectorXd>;
 
  using Base::Base;
 
public:
  using typename Base::Basis;
  using typename Base::DirichletValuesType;
  using typename Base::FEContainer;
  using typename Base::FERequirement;
  using typename Base::GlobalIndex;
 
  using typename Base::ScalarType;
  using typename VectorAssembler<VectorFlatAssembler, FEC, DV, Eigen::VectorXd>::VectorType;
 
protected:
  void assembleRawVectorImpl(const FERequirement& feRequirements, VectorAffordance affordance, VectorType& assemblyVec);
  VectorType& getRawVectorImpl(const FERequirement& feRequirements, VectorAffordance affordance);
  VectorType& getVectorImpl(const FERequirement& feRequirements, VectorAffordance affordance);
 
  VectorType& getReducedVectorImpl(const FERequirement& feRequirements, VectorAffordance affordance);
 
  VectorType vecRaw_{}; 
  VectorType vec_{};    
  VectorType vecRed_{}; 
};
 
#ifndef DOXYGEN
template <class T, class DirichletValuesType>
VectorFlatAssembler(T&& fes, const DirichletValuesType& dirichletValues) -> VectorFlatAssembler<T, DirichletValuesType>;
#endif
 
template <typename FEC, typename DV>
class SparseFlatAssembler : public MatrixAssembler<SparseFlatAssembler<FEC, DV>, FEC, DV, Eigen::SparseMatrix<double>>,
                            public VectorFlatAssembler<FEC, DV>
{
protected:
  using Base = VectorFlatAssembler<FEC, DV>; 
  friend MatrixAssembler<SparseFlatAssembler, FEC, DV, Eigen::SparseMatrix<double>>;
 
  using Base::Base;
 
public:
  using typename Base::Basis;
  using typename Base::DirichletValuesType;
  using typename Base::FEContainer;
  using typename Base::FERequirement;
  using typename Base::GlobalIndex;
  using typename Base::ScalarType;
  using typename Base::VectorType;
  using typename MatrixAssembler<SparseFlatAssembler, FEC, DV, Eigen::SparseMatrix<double>>::MatrixType;
 
private:
  void assembleRawMatrixImpl(const FERequirement& feRequirements, MatrixAffordance affordance, MatrixType& assemblyMat);
 
protected:
  MatrixType& getRawMatrixImpl(const FERequirement& feRequirements, MatrixAffordance affordance);
  MatrixType& getMatrixImpl(const FERequirement& feRequirements, MatrixAffordance affordance);
  MatrixType& getReducedMatrixImpl(const FERequirement& feRequirements, MatrixAffordance affordance);
 
private:
  void createOccupationPattern(MatrixType& assemblyMat);
 
  void createReducedOccupationPattern(MatrixType& assemblyMat);
 
  void createLinearDOFsPerElement(MatrixType& assemblyMat);
 
  void createLinearDOFsPerElementReduced(MatrixType& assemblyMat);
 
  void preProcessSparseMatrix(MatrixType& assemblyMat);
 
  void preProcessSparseMatrixReduced(MatrixType& assemblyMat);
 
  MatrixType spMatRaw_;     
  MatrixType spMat_;        
  MatrixType spMatReduced_; 
  std::vector<std::vector<Eigen::Index>>
      elementLinearIndices_; 
  std::vector<std::vector<Eigen::Index>>
      elementLinearReducedIndices_; 
  bool sparsePreProcessorRaw_{}, sparsePreProcessor_{},
      sparsePreProcessorReduced_{}; 
};
 
#ifndef DOXYGEN
template <class FEC, class DV>
SparseFlatAssembler(FEC&& fes, const DV& dirichletValues) -> SparseFlatAssembler<FEC, DV>;
#endif
 
template <typename FEC, typename DV>
auto makeSparseFlatAssembler(FEC&& fes, const DV& dirichletValues) {
  return std::make_shared<SparseFlatAssembler<FEC, DV>>(std::forward<FEC>(fes), dirichletValues);
}
 
template <typename FEC, typename DV>
class DenseFlatAssembler : public MatrixAssembler<DenseFlatAssembler<FEC, DV>, FEC, DV, Eigen::MatrixXd>,
                           public VectorFlatAssembler<FEC, DV>
{
protected:
  using Base = VectorFlatAssembler<FEC, DV>; 
  friend MatrixAssembler<DenseFlatAssembler, FEC, DV, Eigen::MatrixXd>;
 
  using Base::Base;
 
public:
  using typename Base::Basis;
  using typename Base::DirichletValuesType;
  using typename Base::FEContainer;
  using typename Base::FERequirement;
  using typename Base::GlobalIndex;
  using typename Base::ScalarType;
  using typename Base::VectorType;
  using typename MatrixAssembler<DenseFlatAssembler, FEC, DV, Eigen::MatrixXd>::MatrixType;
 
private:
  void assembleRawMatrixImpl(const FERequirement& feRequirements, MatrixAffordance affordance, MatrixType& assemblyMat);
 
protected:
  MatrixType& getRawMatrixImpl(const FERequirement& feRequirements, MatrixAffordance affordance);
  MatrixType& getMatrixImpl(const FERequirement& feRequirements, MatrixAffordance affordance);
  MatrixType& getReducedMatrixImpl(const FERequirement& feRequirements, MatrixAffordance affordance);
 
private:
  MatrixType matRaw_{}; 
  MatrixType mat_{};    
  MatrixType matRed_{}; 
};
 
#ifndef DOXYGEN
// https://en.cppreference.com/w/cpp/language/class_template_argument_deduction
template <class FEC, class DV>
DenseFlatAssembler(FEC&& fes, const DV& dirichletValues) -> DenseFlatAssembler<FEC, DV>;
#endif
 
template <typename FEC, typename DV>
auto makeDenseFlatAssembler(FEC&& fes, const DV& dirichletValues) {
  return std::make_shared<DenseFlatAssembler<FEC, DV>>(std::forward<FEC>(fes), dirichletValues);
}
} // namespace Ikarus
 
#include "simpleassemblers.inl"