GenericBoundaryCondition.h

Go to the documentation of this file.

#ifndef GENERIC_BOUNDARY_CONDITION_H
#define GENERIC_BOUNDARY_CONDITION_H
 
#include <memory>
#include <string>
#include <utility>
#include <valarray>
#include <vector>
 
#include "SimulationClassBase.h"
 
template <typename T>
class GenericBoundaryCondition
{
    protected:
        SimulationClassBase<T>* m_sim;
        std::vector<int> m_boundary_points;
        std::vector<std::vector<int>> m_connected_points;
        std::vector<std::vector<std::reference_wrapper<T>>> m_capacitance_matrix_elements{};
        std::vector<std::vector<std::reference_wrapper<T>>> m_stiffness_matrix_elements{};
        std::vector<std::reference_wrapper<T>> m_forcing_vector_elements{};
        int m_facet_number{-1};
        std::string m_face_indicator_prefix;
 
    public:
        virtual void writeBoundaryCondition() = 0;
        void registerElementsCsr(GenericMatrix<T>& capacitance_matrix,
                                 GenericMatrix<T>& stiffness_matrix);
        virtual void getReferenceToElements(GenericMatrix<T>& capacitance_matrix,
                                            GenericMatrix<T>& stiffness_matrix,
                                            std::valarray<T>& forcing_vector);
 
        GenericBoundaryCondition(SimulationClassBase<T>* sim, std::vector<int> boundary_points,
                                 std::vector<std::vector<int>> connected_points, int facet_nr,
                                 std::string face_prefix);
        virtual ~GenericBoundaryCondition() = default;
};
 
template <typename T>
GenericBoundaryCondition<T>::GenericBoundaryCondition(
    SimulationClassBase<T>* sim, std::vector<int> boundary_points,
    std::vector<std::vector<int>> connected_points, int facet_nr, std::string face_prefix)
    : m_sim{sim},
      m_boundary_points{std::move(boundary_points)},
      m_connected_points{std::move(connected_points)},
      m_facet_number{facet_nr},
      m_face_indicator_prefix{std::move(face_prefix)}
{
}
 
template <typename T>
void GenericBoundaryCondition<T>::getReferenceToElements(GenericMatrix<T>& capacitance_matrix,
                                                         GenericMatrix<T>& stiffness_matrix,
                                                         std::valarray<T>& forcing_vector)
{
    for (int i{0}; i < m_boundary_points.size(); i++)
    {
        std::vector<std::reference_wrapper<T>> temp_cap_mat{};
        std::vector<std::reference_wrapper<T>> temp_stiff_mat{};
        for (int j{0}; j < m_connected_points[i].size(); j++)
        {
            temp_cap_mat.emplace_back(
                capacitance_matrix(m_boundary_points[i], m_connected_points[i][j]));
            temp_stiff_mat.emplace_back(
                stiffness_matrix(m_boundary_points[i], m_connected_points[i][j]));
        }
        this->m_capacitance_matrix_elements.emplace_back(temp_cap_mat);
        this->m_stiffness_matrix_elements.emplace_back(temp_stiff_mat);
        this->m_forcing_vector_elements.emplace_back(forcing_vector[m_boundary_points[i]]);
    }
}
 
template <typename T>
void GenericBoundaryCondition<T>::registerElementsCsr(GenericMatrix<T>& capacitance_matrix,
                                                      GenericMatrix<T>& stiffness_matrix)
{
    if (capacitance_matrix.getMatrixType() == MatrixType::Csr
        && stiffness_matrix.getMatrixType() == MatrixType::Csr)
    {
        for (int i{0}; i < m_boundary_points.size(); i++)
        {
            for (int j{0}; j < m_connected_points[i].size(); j++)
            {
                capacitance_matrix.registerElement(0.0, m_boundary_points[i],
                                                   m_connected_points[i][j]);
                stiffness_matrix.registerElement(0.0, m_boundary_points[i],
                                                 m_connected_points[i][j]);
            }
        }
    }
}
 
#endif