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 "IniParser.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, heat_capacity, density, source_terms;
    try
    {
        heat_conductivity =
            (this->m_sim->getFieldValue("HeatConductivity", this->m_nodal_values[0])
             + this->m_sim->getFieldValue("HeatConductivity", this->m_nodal_values[1]))
            / 2;
        heat_capacity = (this->m_sim->getFieldValue("HeatCapacity", this->m_nodal_values[0])
                         + this->m_sim->getFieldValue("HeatCapacity", this->m_nodal_values[1]))
                        / 2;
        density = (this->m_sim->getFieldValue("Density", this->m_nodal_values[0])
                   + this->m_sim->getFieldValue("Density", this->m_nodal_values[1]))
                  / 2;
        source_terms = (this->m_sim->getFieldValue("HeatSource", this->m_nodal_values[0])
                        + this->m_sim->getFieldValue("HeatSource", this->m_nodal_values[1]))
                       / 2;
    }
    catch (const std::exception& e)
    {
        std::cerr << "[OneDimLinearElement]: One or more of the necessary base modules (Density, "
                     "HeatCapacity, HeatConductivity, HeatSource) "
                     "not loaded or "
                     "accessable!\n [OneDimLinearElement]:"
                  << e.what() << '\n';
        throw BadInput(static_cast<std::string>(
                           "[OneDimLinearElement]: One or more of the necessary base modules "
                           "(Density, HeatCapacity, HeatConductivity, HeatSource) "
                           "not loaded or "
                           "accessable!\n [OneDimLinearElement]:")
                       + static_cast<std::string>(e.what()));
    }
    // 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