Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// `blaze::DynamicVector` is a general-purpose dynamically sized vector type.
       6             : /// This file implements interoperability of `blaze::DynamicVector` with our
       7             : /// data structures.
       8             : 
       9             : #pragma once
      10             : 
      11             : #include <blaze/math/DynamicVector.h>
      12             : #include <pup.h>
      13             : #include <type_traits>
      14             : #include <vector>
      15             : 
      16             : #include "Utilities/MakeWithValue.hpp"
      17             : #include "Utilities/SetNumberOfGridPoints.hpp"
      18             : 
      19             : /// \cond
      20             : namespace Options {
      21             : struct Option;
      22             : template <typename T>
      23             : struct create_from_yaml;
      24             : }  // namespace Options
      25             : /// \endcond
      26             : 
      27             : namespace PUP {
      28             : /// @{
      29             : /// Serialization of blaze::DynamicVector
      30             : template <typename T, bool TF, typename Tag>
      31             : void pup(er& p, blaze::DynamicVector<T, TF, Tag>& t) {
      32             :   size_t size = t.size();
      33             :   p | size;
      34             :   if (p.isUnpacking()) {
      35             :     t.resize(size);
      36             :   }
      37             :   if (std::is_fundamental_v<T>) {
      38             :     PUParray(p, t.data(), size);
      39             :   } else {
      40             :     for (T& element : t) {
      41             :       p | element;
      42             :     }
      43             :   }
      44             : }
      45             : template <typename T, bool TF, typename Tag>
      46             : void operator|(er& p, blaze::DynamicVector<T, TF, Tag>& t) {
      47             :   pup(p, t);
      48             : }
      49             : /// @}
      50             : }  // namespace PUP
      51             : 
      52           1 : namespace MakeWithValueImpls {
      53             : template <typename T, bool TF, typename Tag>
      54           0 : struct NumberOfPoints<blaze::DynamicVector<T, TF, Tag>> {
      55             :   static SPECTRE_ALWAYS_INLINE size_t
      56           0 :   apply(const blaze::DynamicVector<T, TF, Tag>& input) {
      57             :     return input.size();
      58             :   }
      59             : };
      60             : 
      61             : template <typename T, bool TF, typename Tag>
      62           0 : struct MakeWithSize<blaze::DynamicVector<T, TF, Tag>> {
      63           0 :   static SPECTRE_ALWAYS_INLINE blaze::DynamicVector<T, TF, Tag> apply(
      64             :       const size_t size, const T& value) {
      65             :     return blaze::DynamicVector<T, TF, Tag>(size, value);
      66             :   }
      67             : };
      68             : }  // namespace MakeWithValueImpls
      69             : 
      70             : template <typename T, bool TF, typename Tag>
      71           0 : struct SetNumberOfGridPointsImpls::SetNumberOfGridPointsImpl<
      72             :     blaze::DynamicVector<T, TF, Tag>> {
      73           0 :   static constexpr bool is_trivial = false;
      74           0 :   static SPECTRE_ALWAYS_INLINE void apply(
      75             :       const gsl::not_null<blaze::DynamicVector<T, TF, Tag>*> result,
      76             :       const size_t size) {
      77             :     result->resize(size);
      78             :   }
      79             : };
      80             : 
      81             : namespace DynamicVector_detail {
      82             : template <typename T>
      83             : std::vector<T> parse_to_vector(const Options::Option& options);
      84             : }  // namespace DynamicVector_detail
      85             : 
      86             : template <typename T, bool TF, typename Tag>
      87           0 : struct Options::create_from_yaml<blaze::DynamicVector<T, TF, Tag>> {
      88             :   template <typename Metavariables>
      89           0 :   static blaze::DynamicVector<T, TF, Tag> create(
      90             :       const Options::Option& options) {
      91             :     const auto data = DynamicVector_detail::parse_to_vector<T>(options);
      92             :     blaze::DynamicVector<T, TF, Tag> result(data.size());
      93             :     std::copy(std::begin(data), std::end(data), result.begin());
      94             :     return result;
      95             :   }
      96             : };