variableAttributeLoader.h

#ifndef VARIABLEATTRIBUTELOADER_H
#define VARIABLEATTRIBUTELOADER_H
 
#include <core/varTypeEnums.h>
#include <core/variableAttributes.h>
#include <map>
#include <string>
 
using EvalFlags = dealii::EvaluationFlags::EvaluationFlags;
 
class variableAttributeLoader
{
public:
  variableAttributeLoader() = default;
 
  virtual ~variableAttributeLoader() = default;
 
  void
  init_variable_attributes();
 
  [[nodiscard]] AttributesList
  get_var_attributes() const;
 
  [[nodiscard]] AttributesList
  get_pp_attributes() const;
 
protected:
  virtual void
  loadVariableAttributes();
 
  virtual void
  loadPostProcessorVariableAttributes();
 
  void
  set_variable_name(const unsigned int &index, const std::string &name) const;
 
  void
  set_variable_type(const unsigned int &index, const fieldType &var_type) const;
 
  void
  set_variable_equation_type(const unsigned int &index, const PDEType &var_eq_type) const;
 
  void
  set_dependencies_value_term_RHS(const unsigned int &index,
                                  const std::string  &dependencies);
 
  void
  set_dependencies_gradient_term_RHS(const unsigned int &index,
                                     const std::string  &dependencies);
 
  void
  set_dependencies_value_term_LHS(const unsigned int &index,
                                  const std::string  &dependencies) const;
 
  void
  set_dependencies_gradient_term_LHS(const unsigned int &index,
                                     const std::string  &dependencies) const;
 
  template <typename Iterable>
  void
  insert_dependencies_value_term_RHS(const unsigned int &index,
                                     const Iterable     &dependencies);
 
  template <typename Iterable>
  void
  insert_dependencies_gradient_term_RHS(const unsigned int &index,
                                        const Iterable     &dependencies);
 
  template <typename Iterable>
  void
  insert_dependencies_value_term_LHS(const unsigned int &index,
                                     const Iterable     &dependencies) const;
 
  template <typename Iterable>
  void
  insert_dependencies_gradient_term_LHS(const unsigned int &index,
                                        const Iterable     &dependencies) const;
 
  void
  set_need_value_nucleation(const unsigned int &index, const bool &flag) const;
 
  void
  set_allowed_to_nucleate(const unsigned int &index, const bool &flag) const;
 
  void
  set_output_integral(const unsigned int &index, const bool &flag) const;
 
private:
  AttributesList var_attributes;
 
  AttributesList pp_attributes;
 
  AttributesList *relevant_attributes = nullptr;
 
  void
  validate_attributes();
 
  static void
  validate_variable_name(const std::string           &name,
                         const std::set<std::string> &forbidden_names,
                         const std::string           &context,
                         unsigned int                 index);
 
  static void
  populate_dependencies(
    const std::set<std::pair<std::string, std::string>> &reg_delimiters,
    const std::string                                   &variable_name,
    unsigned int                                         index,
    std::set<std::string>                               &reg_possible_deps,
    std::map<uint, std::set<std::string>>               &change_possible_deps);
 
  static void
  validate_dependencies(
    const std::set<std::string>                 &dependencies,
    const std::string                           &context,
    unsigned int                                 index,
    const std::string                           &variable_name,
    const std::set<std::string>                 &reg_possible_deps,
    const std::map<uint, std::set<std::string>> &change_possible_deps);
 
  static void
  validate_postprocess_variable(const std::string           &name,
                                const std::set<std::string> &name_list,
                                const std::set<std::string> &reg_possible_deps,
                                const variableAttributes    &pp_variable,
                                unsigned int                 index);
 
  static std::string
  strip_whitespace(const std::string &text);
  // The above function should be moved to a 'utilities' module
};
 
// Template derived class for variableAttributeLoader for applications.
// `loadVariableAttributes()` and `loadPostProcessorVariableAttributes()` are should be
// filled out in all the applications.
class customAttributeLoader : public variableAttributeLoader
{
public:
  ~customAttributeLoader() override = default;
 
  void
  loadVariableAttributes() override;
 
  void
  loadPostProcessorVariableAttributes() override;
};
 
#endif