variable_attributes.h

// SPDX-FileCopyrightText: © 2025 PRISMS Center at the University of Michigan
// SPDX-License-Identifier: GNU Lesser General Public Version 2.1
 
#ifndef variable_attributes_h
#define variable_attributes_h
 
#include <deal.II/matrix_free/evaluation_flags.h>
 
#include <prismspf/config.h>
#include <prismspf/core/type_enums.h>
#include <prismspf/core/types.h>
 
#include <map>
#include <set>
#include <string>
#include <unordered_map>
 
PRISMS_PF_BEGIN_NAMESPACE
 
struct pairHash
{
public:
  template <typename T, typename U>
  std::size_t
  operator()(const std::pair<T, U> &x) const
  {
    return std::hash<T>()(x.first) ^ std::hash<U>()(x.second);
  }
};
struct pairHash {…};
 
struct variableAttributes
{
  std::string name;
 
  types::index field_index = numbers::invalid_index;
 
  fieldType field_type = fieldType::UNDEFINED_FIELD;
 
  PDEType pde_type = PDEType::UNDEFINED_PDE;
 
  bool is_postprocess = false;
 
#ifdef ADDITIONAL_OPTIMIZATIONS
  mutable types::index duplicate_field_index = numbers::invalid_index;
#endif
 
  fieldSolveType field_solve_type = fieldSolveType::UNDEFINED_SOLVE;
 
  std::set<std::string> dependencies_value_RHS;
 
  std::set<std::string> dependencies_gradient_RHS;
 
  std::set<std::string> dependencies_RHS;
 
  std::set<std::string> dependencies_value_LHS;
 
  std::set<std::string> dependencies_gradient_LHS;
 
  std::set<std::string> dependencies_LHS;
 
  std::unordered_map<std::pair<unsigned int, dependencyType>,
                     dealii::EvaluationFlags::EvaluationFlags,
                     pairHash>
    eval_flag_set_RHS;
 
  std::unordered_map<std::pair<unsigned int, dependencyType>,
                     dealii::EvaluationFlags::EvaluationFlags,
                     pairHash>
    eval_flag_set_LHS;
 
  dealii::EvaluationFlags::EvaluationFlags eval_flags_residual_RHS =
    dealii::EvaluationFlags::nothing;
 
  dealii::EvaluationFlags::EvaluationFlags eval_flags_residual_LHS =
    dealii::EvaluationFlags::nothing;
 
  std::map<unsigned int, std::map<dependencyType, fieldType>> dependency_set_RHS;
 
  std::map<unsigned int, std::map<dependencyType, fieldType>> dependency_set_LHS;
 
  std::set<unsigned int> simplified_dependency_set;
 
  void
  format_dependencies();
 
  void
  parse_residual_dependencies();
 
  void
  parse_dependencies(std::map<unsigned int, variableAttributes> &other_var_attributes);
 
  void
  determine_field_solve_type(
    std::map<unsigned int, variableAttributes> &other_var_attributes);
 
  void
  print() const;
 
private:
  void
  validate_dependency(const std::string  &variation,
                      dependencyType      dep_type,
                      const unsigned int &other_index,
                      const std::string  &context) const;
 
  void
  compute_dependency_set(
    const std::map<unsigned int, variableAttributes> &other_var_attributes);
 
  void
  compute_simplified_dependency_set(
    const std::map<unsigned int, variableAttributes> &other_var_attributes);
 
  void
  find_circular_dependencies(
    const std::map<unsigned int, variableAttributes> &other_var_attributes);
 
  void
  recursive_DFS(const std::map<unsigned int, variableAttributes> &other_var_attributes,
                std::set<unsigned int>                           &visited,
                std::set<unsigned int>                           &current_stack,
                const unsigned int                               &vertex);
};
struct variableAttributes {…};
 
PRISMS_PF_END_NAMESPACE
 
#endif