Detailed Description

Definition at line 49 of file LookupTable.h.

#include <LookupTable.h>

Public Member Functions
	LookupTable (std::vector< Field > input_fields_, std::map< std::string, std::vector< double > > tabular_data_)

void	lookup (std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, std::size_t const n_nodes) const

std::size_t	getTableEntryID (std::vector< double > const &entry_input) const

Public Attributes
std::vector< Field > const	input_fields

std::map< std::string, std::vector< double > > const	tabular_data

Constructor & Destructor Documentation

◆ LookupTable()

ProcessLib::ComponentTransport::LookupTable::LookupTable	(	std::vector< Field >	input_fields_,
		std::map< std::string, std::vector< double > >	tabular_data_ )

inline

Definition at line 51 of file LookupTable.h.

        : input_fields(std::move(input_fields_)),
          tabular_data(std::move(tabular_data_))
    {
    }

Member Function Documentation

◆ getTableEntryID()

std::size_t ProcessLib::ComponentTransport::LookupTable::getTableEntryID ( std::vector< double > const & entry_input ) const

point_id_groups stores indices where the elements equal to the given value.

need to intersect point_id_groups with respect to different input fields to find out an entry id where all the field data align with the entry inputs.

Definition at line 139 of file LookupTable.cpp.

{
    std::vector<std::size_t> intersected_vec =
        input_fields[0].point_id_groups[BaseLib::findIndex(
            input_fields[0].seed_points, entry_input[0])];
 
    for (std::size_t i = 1; i < input_fields.size(); ++i)
    {
        std::vector<std::size_t> const vec =
            input_fields[i].point_id_groups[BaseLib::findIndex(
                input_fields[i].seed_points, entry_input[i])];
 
        intersection(intersected_vec, vec);
    }
 
    return intersected_vec[0];
}

References BaseLib::findIndex(), input_fields, and ProcessLib::ComponentTransport::intersection().

Referenced by lookup().

◆ lookup()

void ProcessLib::ComponentTransport::LookupTable::lookup	(	std::vector< GlobalVector * > const &	x,
		std::vector< GlobalVector * > const &	x_prev,
		std::size_t const	n_nodes ) const

Definition at line 61 of file LookupTable.cpp.

{
    using EntryInput = std::vector<double>;
 
    for (std::size_t node_id = 0; node_id < n_nodes; ++node_id)
    {
        std::vector<InterpolationPoint> interpolation_points;
        EntryInput base_entry_input;
        for (auto const& input_field : input_fields)
        {
            // process id and variable id are equivalent in the case the
            // staggered coupling scheme is adopted.
            auto const process_id = input_field.variable_id;
            auto const& variable_name = input_field.name;
            double input_field_value =
                variable_name.find("_prev") == std::string::npos
                    ? x[process_id]->get(node_id)
                    : x_prev[process_id]->get(node_id);
            input_field_value =
                (std::abs(input_field_value) + input_field_value) / 2;
            auto bounding_seed_points =
                input_field.getBoundingSeedPoints(input_field_value);
 
            InterpolationPoint interpolation_point{bounding_seed_points,
                                                   input_field_value};
            interpolation_points.push_back(interpolation_point);
 
            base_entry_input.push_back(bounding_seed_points.first);
        }
 
        auto const base_entry_id = getTableEntryID(base_entry_input);
 
        // collect bounding entry ids
        EntryInput bounding_entry_input{base_entry_input};
        std::vector<std::size_t> bounding_entry_ids;
        for (std::size_t i = 0; i < interpolation_points.size(); ++i)
        {
            bounding_entry_input[i] =
                interpolation_points[i].bounding_points.second;
            bounding_entry_ids.push_back(getTableEntryID(bounding_entry_input));
            bounding_entry_input[i] =
                interpolation_points[i].bounding_points.first;
        }
 
        for (auto const& input_field : input_fields)
        {
            if (input_field.name.find("_prev") != std::string::npos)
            {
                continue;
            }
 
            auto const output_field_name = input_field.name + "_new";
            auto const base_value =
                tabular_data.at(output_field_name)[base_entry_id];
            auto new_value = base_value;
 
            // linear interpolation
            for (std::size_t i = 0; i < interpolation_points.size(); ++i)
            {
                auto const interpolation_point_value =
                    tabular_data.at(output_field_name)[bounding_entry_ids[i]];
                auto const slope =
                    (interpolation_point_value - base_value) /
                    (interpolation_points[i].bounding_points.second -
                     interpolation_points[i].bounding_points.first);
 
                new_value +=
                    slope * (interpolation_points[i].value -
                             interpolation_points[i].bounding_points.first);
            }
 
            x[input_field.variable_id]->set(node_id, new_value);
        }
    }
}

References getTableEntryID(), input_fields, and tabular_data.

Member Data Documentation

◆ input_fields

std::vector<Field> const ProcessLib::ComponentTransport::LookupTable::input_fields

Definition at line 65 of file LookupTable.h.

Referenced by getTableEntryID(), and lookup().

◆ tabular_data

std::map<std::string, std::vector<double> > const ProcessLib::ComponentTransport::LookupTable::tabular_data

Definition at line 66 of file LookupTable.h.