OneDimLinearElement.h

Go to the documentation of this file.

#ifndef ONE_D_LINEAR_ELEMENT
#define ONE_D_LINEAR_ELEMENT
 
#include <map>
#include <memory>
#include <valarray>
#include <vector>
 
#include "GenericElement.h"
#include "SimulationClassBase.h"
 
template <typename T>
class OneDimLinearElement : public GenericElement<T>
{
    private:
        T m_area;
        T m_element_length;
 
    public:
        void writeMatrixVectorBlock() override;
        void writeBoundaryCondition() override;
 
        OneDimLinearElement(bool is_boundary_point,
                            std::map<std::string_view, std::vector<int>> all_boundary_points,
                            std::vector<int> nodal_values, SimulationClassBase<T>* sim, int cell_nr,
                            ElementProperties<T> props);
        ~OneDimLinearElement() override = default;
};
 
template <typename T>
OneDimLinearElement<T>::OneDimLinearElement(
    bool is_boundary_point, std::map<std::string_view, std::vector<int>> all_boundary_points,
    std::vector<int> nodal_values, SimulationClassBase<T>* sim, int cell_nr,
    ElementProperties<T> props)
    : GenericElement<T>{is_boundary_point, all_boundary_points, nodal_values, sim, cell_nr, props},
      m_area(this->m_properties.element_area),
      m_element_length(this->m_properties.element_length)
{
}
 
template <typename T>
void OneDimLinearElement<T>::writeMatrixVectorBlock()
{
    T heat_conductivity =
        (this->m_sim->getFieldValue("HeatConductivity", this->m_nodal_values[0])
         + this->m_sim->getFieldValue("HeatConductivity", this->m_nodal_values[1]))
        / 2;
    T heat_capacity = (this->m_sim->getFieldValue("HeatCapacity", this->m_nodal_values[0])
                       + this->m_sim->getFieldValue("HeatCapacity", this->m_nodal_values[1]))
                      / 2;
    T density = (this->m_sim->getFieldValue("Density", this->m_nodal_values[0])
                 + this->m_sim->getFieldValue("Density", this->m_nodal_values[1]))
                / 2;
    T source_terms = (this->m_sim->getFieldValue("HeatSource", this->m_nodal_values[0])
                      + this->m_sim->getFieldValue("HeatSource", this->m_nodal_values[1]))
                     / 2;
    // T area{ SHAPEMODEL.getArea(this->m_element_nr)};
 
    // Capacitance matrix entries
    this->m_capacitance_matrix_elements[0] +=
        2 * density * heat_capacity * m_area * m_element_length / 6;
    this->m_capacitance_matrix_elements[1] +=
        density * heat_capacity * m_area * m_element_length / 6;
    this->m_capacitance_matrix_elements[2] +=
        density * heat_capacity * m_area * m_element_length / 6;
    this->m_capacitance_matrix_elements[3] +=
        2 * density * heat_capacity * m_area * m_element_length / 6;
 
    // Stiffness matrix entries
    this->m_stiffness_matrix_elements[0] += heat_conductivity * m_area / m_element_length;
    this->m_stiffness_matrix_elements[1] -= heat_conductivity * m_area / m_element_length;
    this->m_stiffness_matrix_elements[2] -= heat_conductivity * m_area / m_element_length;
    this->m_stiffness_matrix_elements[3] += heat_conductivity * m_area / m_element_length;
 
    // Forcing vector entries
    this->m_forcing_vector_elements[0] += m_area * source_terms * m_element_length / 2;
    this->m_forcing_vector_elements[1] += m_area * source_terms * m_element_length / 2;
}
 
template <typename T>
void OneDimLinearElement<T>::writeBoundaryCondition()
{
    for (auto& [key, boundary_condition] : this->m_boundary_conditions)
    {
        writeMatrixVectorBlock();  // The interior entries of the boundary are never changed, so
                                   // they need to be calculated
        boundary_condition->writeBoundaryCondition();  // Then everything reading the boundary
                                                       // condition is calculated (and overwrites
                                                       // the previous values if necessary)
    }
}
 
#endif