field_types.hpp

Go to the documentation of this file.

// Copyright Lawrence Livermore National Security, LLC and
// other Smith Project Developers. See the top-level LICENSE file for
// details.
//
// SPDX-License-Identifier: (BSD-3-Clause)
 
#pragma once
 
#include "smith/physics/state/finite_element_state.hpp"
#include "smith/physics/state/finite_element_dual.hpp"
 
namespace smith {
 
constexpr int SHAPE_ORDER = 1;
 
constexpr H1<SHAPE_ORDER, 2> SHAPE_DIM_2;
 
constexpr H1<SHAPE_ORDER, 3> SHAPE_DIM_3;
 
using FieldPtr = FiniteElementState*;
 
using DualFieldPtr = FiniteElementDual*;
 
using ConstFieldPtr = FiniteElementState const*;
 
using ConstDualFieldPtr = FiniteElementDual const*;
 
template <typename T>
auto getFieldPointers(std::vector<std::shared_ptr<T>>& states, std::vector<std::shared_ptr<T>>& params)
{
  static_assert(std::is_same_v<T, FiniteElementState> || std::is_same_v<T, FiniteElementDual>,
                "Type must be either FiniteElementState or FiniteElementDual");
  std::vector<T*> pointers;
  for (auto& t : states) {
    pointers.push_back(t.get());
  }
  for (auto& t : params) {
    pointers.push_back(t.get());
  }
  return pointers;
}
 
template <typename T>
auto getFieldPointers(std::vector<std::shared_ptr<T>>& states)
{
  static_assert(std::is_same_v<T, FiniteElementState> || std::is_same_v<T, FiniteElementDual>,
                "Type must be either FiniteElementState or FiniteElementDual");
  std::vector<T*> pointers;
  for (auto& t : states) {
    pointers.push_back(t.get());
  }
  return pointers;
}
 
template <typename T>
auto getFieldPointers(std::vector<T>& states, std::vector<T>& params)
{
  static_assert(std::is_same_v<T, FiniteElementState> || std::is_same_v<T, FiniteElementDual>,
                "Type must be either FiniteElementState or FiniteElementDual");
  std::vector<T*> pointers;
  for (auto& t : states) {
    pointers.push_back(&t);
  }
  for (auto& t : params) {
    pointers.push_back(&t);
  }
  return pointers;
}
 
template <typename T>
auto getFieldPointers(std::vector<T>& states)
{
  static_assert(std::is_same_v<T, FiniteElementState> || std::is_same_v<T, FiniteElementDual>,
                "Type must be either FiniteElementState or FiniteElementDual");
  std::vector<T*> pointers;
  for (auto& t : states) {
    pointers.push_back(&t);
  }
  return pointers;
}
 
template <typename T>
auto getFieldPointers(std::shared_ptr<T>& state)
{
  static_assert(std::is_same_v<T, FiniteElementState> || std::is_same_v<T, FiniteElementDual>,
                "Type must be either FiniteElementState or FiniteElementDual");
  return std::vector<T*>{state.get()};
}
 
template <typename T>
auto getFieldPointers(T& state)
{
  static_assert(std::is_same_v<T, FiniteElementState> || std::is_same_v<T, FiniteElementDual>,
                "Type must be either FiniteElementState or FiniteElementDual");
  return std::vector<T*>{&state};
}
 
template <typename T>
auto getConstFieldPointers(const std::vector<std::shared_ptr<T>>& states,
                           const std::vector<std::shared_ptr<T>>& params = {})
{
  static_assert(std::is_same_v<T, FiniteElementState> || std::is_same_v<T, FiniteElementDual>,
                "Type must be either FiniteElementState or FiniteElementDual");
  std::vector<T const*> pointers;
  for (auto& t : states) {
    pointers.push_back(t.get());
  }
  for (auto& t : params) {
    pointers.push_back(t.get());
  }
  return pointers;
}
 
template <typename T>
auto getConstFieldPointers(const std::vector<T*>& states, const std::vector<T*>& params = {})
{
  static_assert(std::is_same_v<T, FiniteElementState> || std::is_same_v<T, FiniteElementDual>,
                "Type must be either FiniteElementState or FiniteElementDual");
  std::vector<T const*> pointers;
  for (auto& t : states) {
    pointers.push_back(t);
  }
  for (auto& t : params) {
    pointers.push_back(t);
  }
  return pointers;
}
 
template <typename T>
auto getConstFieldPointers(const std::vector<T>& states, const std::vector<T>& params = {})
{
  static_assert(std::is_same_v<T, FiniteElementState> || std::is_same_v<T, FiniteElementDual>,
                "Type must be either FiniteElementState or FiniteElementDual");
  std::vector<T const*> pointers;
  for (auto& t : states) {
    pointers.push_back(&t);
  }
  for (auto& t : params) {
    pointers.push_back(&t);
  }
  return pointers;
}
 
template <typename T>
auto getConstFieldPointers(const std::shared_ptr<T>& state)
{
  static_assert(std::is_same_v<T, FiniteElementState> || std::is_same_v<T, FiniteElementDual>,
                "Type must be either FiniteElementState or FiniteElementDual");
  return std::vector<T const*>{state.get()};
}
 
template <typename T>
auto getConstFieldPointers(const T& state)
{
  static_assert(std::is_same_v<T, FiniteElementState> || std::is_same_v<T, FiniteElementDual>,
                "Type must be either FiniteElementState or FiniteElementDual");
  return std::vector<T const*>{&state};
}
 
}  // namespace smith