quadrature_data.hpp

Go to the documentation of this file.

// Copyright (c) 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 <cstddef>
#include <array>
#include <cstdint>
#include <map>
#include <memory>
#include <string_view>
 
#include "mfem.hpp"
#include "axom/core.hpp"
#include "smith/smith_config.hpp"
#include "smith/infrastructure/accelerator.hpp"
 
namespace smith {
 
struct Nothing {};
 
struct Empty {};
 
template <typename T>
struct QuadratureData;
 
}  // namespace smith
 
// we define these specializations to make it so that materials
// without state variables can use the same interface, without
// actually storing/accessing any data
namespace axom {
 
template <>
class Array<smith::Nothing, 2, MemorySpace::Dynamic> {
 public:
  Array() {}
  Array(uint32_t, uint32_t) {}
};
 
template <>
class ArrayView<smith::Nothing, 2, MemorySpace::Dynamic> {
 public:
  ArrayView(Array<smith::Nothing, 2, MemorySpace::Dynamic> /* unused */) {}
 
  SMITH_HOST_DEVICE smith::Nothing& operator()(const size_t, const size_t) { return data; }
 
  SMITH_HOST_DEVICE const smith::Nothing& operator()(const size_t, const size_t) const { return data; }
 
  smith::Nothing data;
};
 
template <>
class Array<smith::Empty, 2, MemorySpace::Dynamic> {
 public:
  Array() {}
  Array(uint32_t, uint32_t) {}
};
 
template <>
class ArrayView<smith::Empty, 2, MemorySpace::Dynamic> {
 public:
  ArrayView(Array<smith::Empty, 2, MemorySpace::Dynamic> /* unused */) {}
 
  SMITH_HOST_DEVICE smith::Empty& operator()(const size_t, const size_t) { return data; }
 
  SMITH_HOST_DEVICE const smith::Empty& operator()(const size_t, const size_t) const { return data; }
 
  smith::Empty data;
};
 
}  // namespace axom
 
namespace smith {
namespace detail {
 
// Note: The indexes between these two arrays must match the type in qdata_geometries to the name in
// qdata_geometry_names
constexpr std::array<mfem::Geometry::Type, 5> qdata_geometries = {mfem::Geometry::SEGMENT, mfem::Geometry::TRIANGLE,
                                                                  mfem::Geometry::SQUARE, mfem::Geometry::TETRAHEDRON,
                                                                  mfem::Geometry::CUBE};
constexpr std::array<std::string_view, 5> qdata_geometry_names = {"Segment", "Triangle", "Square", "Tetrahedron",
                                                                  "Cube"};
}  // namespace detail
 
template <typename T>
struct QuadratureData {
  using geom_array_t = std::array<uint32_t, mfem::Geometry::NUM_GEOMETRIES>;
 
  QuadratureData(geom_array_t elements, geom_array_t qpts_per_element, T value = T{})
  {
    for (auto geom : detail::qdata_geometries) {
      if (elements[uint32_t(geom)] > 0) {
        data[geom] = axom::Array<T, 2>(elements[uint32_t(geom)], qpts_per_element[uint32_t(geom)]);
        data[geom].fill(value);
      }
    }
  }
 
  axom::ArrayView<T, 2> operator[](mfem::Geometry::Type geom) { return axom::ArrayView<T, 2>(data.at(geom)); }
 
  std::map<mfem::Geometry::Type, axom::Array<T, 2>> data;
};
 
template <>
struct QuadratureData<Nothing> {
  using geom_array_t = std::array<uint32_t, mfem::Geometry::NUM_GEOMETRIES>;
 
  QuadratureData() {}
 
  axom::ArrayView<Nothing, 2> operator[](mfem::Geometry::Type) { return axom::ArrayView<Nothing, 2>(data); }
 
  axom::Array<Nothing, 2, axom::MemorySpace::Dynamic> data;
};
 
template <>
struct QuadratureData<Empty> {
  using geom_array_t = std::array<uint32_t, mfem::Geometry::NUM_GEOMETRIES>;
 
  QuadratureData() {}
 
  axom::ArrayView<Empty, 2> operator[](mfem::Geometry::Type) { return axom::ArrayView<Empty, 2>(data); }
 
  axom::Array<Empty, 2, axom::MemorySpace::Dynamic> data;
};
 
extern std::shared_ptr<QuadratureData<Nothing>> NoQData;
extern std::shared_ptr<QuadratureData<Empty>> EmptyQData;
 
}  // namespace smith