field_attributes.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: © 2026 PRISMS Center at the University of Michigan
// SPDX-License-Identifier: GNU Lesser General Public Version 2.1
 
#pragma once
 
#include <deal.II/base/exceptions.h>
 
#include <prismspf/core/type_enums.h>
#include <prismspf/core/types.h>
 
#include <prismspf/user_inputs/constraint_parameters.h>
 
#include <prismspf/config.h>
 
#include <map>
#include <string>
#include <vector>
 
PRISMS_PF_BEGIN_NAMESPACE

struct FieldAttributes
{
  explicit FieldAttributes(
    std::string               _name                        = "",
    TensorRank                _field_type                  = TensorRank::Scalar,
    BoundaryConditionSet      _boundary_conditions         = BoundaryConditionSet(),
    bool                      _is_nucleation_rate_variable = false,
    std::vector<Types::Index> _nucleating_field_indices    = std::vector<Types::Index>())
    : name(std::move(_name))
    , field_type(_field_type)
    , boundary_conditions(std::move(_boundary_conditions))
    , is_nucleation_rate_variable(_is_nucleation_rate_variable)
    , nucleating_field_indices(std::move(_nucleating_field_indices))
  {}

  std::string name;

  TensorRank field_type = TensorRank::Scalar;

  BoundaryConditionSet boundary_conditions;

  bool is_nucleation_rate_variable = false;

  std::vector<Types::Index> nucleating_field_indices;
};

inline std::map<std::string, Types::Index>
field_index_map(const std::vector<FieldAttributes> &fields)
{
  std::map<std::string, Types::Index> map;
  for (unsigned int i = 0; i < fields.size(); ++i)
    {
      AssertThrow(map.find(fields[i].name) == map.end(),
                  dealii::ExcMessage(
                    "The names of the fields are not unique. This is not allowed."));
      map[fields[i].name] = i;
    }
  return map;
}

inline std::map<std::string, FieldAttributes>
field_map(const std::vector<FieldAttributes> &fields)
{
  std::map<std::string, FieldAttributes> map;
  for (const FieldAttributes &field : fields)
    {
      AssertThrow(map.find(field.name) == map.end(),
                  dealii::ExcMessage(
                    "The names of the fields are not unique. This is not allowed."));
      map[field.name] = field;
    }
  return map;
}
 
// TODO: Submit a PR/issue to dealii to make operator| constexpr.
// constexpr EvalFlags values_and_gradients = EvalFlags::values |
// EvalFlags::gradients;
 
PRISMS_PF_END_NAMESPACE