GenericElement.h

Go to the documentation of this file.

#ifndef GENERIC_ELEMENT_H
#define GENERIC_ELEMENT_H
 
#include <functional>
#include <map>
#include <memory>
#include <utility>
#include <valarray>
#include <vector>
 
#include "GenericBoundaryCondition.h"
#include "GenericMatrix.h"
#include "SimulationClassBase.h"
 
template <typename T>
struct ElementProperties
{
        T element_length{};
        T element_area{};
};
 
template <typename T>
class GenericElement
{
    protected:
        bool m_is_boundary;
        std::map<std::string_view, std::vector<int>>
            m_boundary_points;  // Map that holds the boundary type and the nodes which are
                                // boundary points in that element
        std::vector<int> m_nodal_values;
        std::vector<std::reference_wrapper<T>> m_capacitance_matrix_elements{};
        std::vector<std::reference_wrapper<T>> m_stiffness_matrix_elements{};
        std::vector<std::reference_wrapper<T>> m_forcing_vector_elements{};
        SimulationClassBase<T>* m_sim{};
        int m_element_nr{-1};
        std::map<std::string_view, std::unique_ptr<GenericBoundaryCondition<T>>>
            m_boundary_conditions{};
        ElementProperties<T> m_properties{};
 
    public:
        virtual void writeMatrixVectorBlock() = 0;
        virtual void writeBoundaryCondition() = 0;
 
        void setBoundaryConditions(
            std::map<std::string_view, std::unique_ptr<GenericBoundaryCondition<T>>>&
                boundary_cond);
        std::map<std::string_view, std::unique_ptr<GenericBoundaryCondition<T>>>&
        getBoundaryCondition()
        {
            return m_boundary_conditions;
        }
        void getReferenceToElements(GenericMatrix<T>& capacitance_matrix,
                                    GenericMatrix<T>& stiffness_matrix,
                                    std::valarray<T>& forcing_vector);
        bool isBoundary() { return m_is_boundary; }
 
        GenericElement(bool is_boundary_point,
                       std::map<std::string_view, std::vector<int>> all_boundary_points,
                       std::vector<int> nodal_values, SimulationClassBase<T>* sim, int num_cell,
                       ElementProperties<T> properties);
        virtual ~GenericElement() = default;
};
 
template <typename T>
GenericElement<T>::GenericElement(bool is_boundary_point,
                                  std::map<std::string_view, std::vector<int>> all_boundary_points,
                                  std::vector<int> nodal_values, SimulationClassBase<T>* sim,
                                  int num_cell, ElementProperties<T> properties)
    : m_is_boundary{is_boundary_point},
      m_boundary_points{std::move(all_boundary_points)},
      m_nodal_values{std::move(nodal_values)},
      m_sim{sim},
      m_element_nr{num_cell},
      m_properties{properties}
{
}
 
template <typename T>
void GenericElement<T>::setBoundaryConditions(
    std::map<std::string_view, std::unique_ptr<GenericBoundaryCondition<T>>>& boundary_cond)
{
    m_boundary_conditions = std::move(boundary_cond);
}
 
template <typename T>
void GenericElement<T>::getReferenceToElements(GenericMatrix<T>& capacitance_matrix,
                                               GenericMatrix<T>& stiffness_matrix,
                                               std::valarray<T>& forcing_vector)
{
    for (int i : this->m_nodal_values)
    {
        for (int j : this->m_nodal_values)
        {
            this->m_capacitance_matrix_elements.emplace_back(capacitance_matrix(i, j));
            this->m_stiffness_matrix_elements.emplace_back(stiffness_matrix(i, j));
        }
        this->m_forcing_vector_elements.emplace_back(forcing_vector[i]);
    }
}
 
#endif