Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <array>
       7              : #include <cstddef>
       8              : #include <vector>
       9              : 
      10              : #include "DataStructures/DataVector.hpp"
      11              : #include "Utilities/Gsl.hpp"
      12              : 
      13              : namespace ylm::Spherepack_detail {
      14              : 
      15              : /// Holds the various constant 'work' arrays for Spherepack.
      16              : /// These are computed only once during ylm::Spherepack construction
      17              : /// and are re-used over and over again.
      18              : class ConstStorage {
      19              :  public:
      20              :   ConstStorage(const size_t l_max, const size_t m_max);
      21              :   ~ConstStorage() = default;
      22              :   ConstStorage(const ConstStorage& rhs);
      23              :   ConstStorage& operator=(const ConstStorage& rhs);
      24              :   ConstStorage(ConstStorage&& rhs);
      25              :   ConstStorage& operator=(ConstStorage&& rhs);
      26              : 
      27              :   std::vector<size_t> work_interp_index;
      28              :   // The following are vectors because they are returnable by
      29              :   // member functions.
      30              :   std::vector<double> quadrature_weights, theta, phi;
      31              :   // All other storage is allocated in a single DataVector and then
      32              :   // pointed to by gsl::spans.
      33              :   DataVector storage_;
      34              :   gsl::span<double> work_phys_to_spec, work_scalar_spec_to_phys;
      35              :   gsl::span<double> work_vector_spec_to_phys;
      36              :   gsl::span<double> sin_theta, cos_theta, cosec_theta, cot_theta;
      37              :   gsl::span<double> sin_phi, cos_phi;
      38              :   gsl::span<double> work_interp_alpha, work_interp_beta, work_interp_pmm;
      39              : 
      40              :  private:
      41              :   size_t l_max_;
      42              :   size_t m_max_;
      43              :   void point_spans_to_data_vector(const bool allocate = false);
      44              : };
      45              : 
      46              : /// This is a quick way of providing temporary space that is
      47              : /// re-utilized many times without the expense of mallocs.  This
      48              : /// turned out to be important for optimizing SpEC (because
      49              : /// ylm::Spherepack is used for the basis functions in the most
      50              : /// expensive subdomains) but may or may not be important for SpECTRE.
      51              : class MemoryPool {
      52              :  public:
      53              :   MemoryPool() = default;
      54              :   std::vector<double>& get(size_t n_pts);
      55              :   void free(const std::vector<double>& to_be_freed);
      56              :   void free(gsl::not_null<double*> to_be_freed);
      57              :   void clear();
      58              : 
      59              :  private:
      60              :   struct StorageAndAvailability {
      61              :     std::vector<double> storage;
      62              :     bool currently_in_use{false};
      63              :   };
      64              :   // It turns out that the maximum number of temporaries needed in a
      65              :   // single ylm::Spherepack calculation is 9.
      66              :   static const constexpr size_t num_temps_ = 9;
      67              :   std::array<StorageAndAvailability, num_temps_> memory_pool_;
      68              : };
      69              : }  // namespace ylm::Spherepack_detail