knots_as_interpolation_points.hpp

// Copyright (C) The DDC development team, see COPYRIGHT.md file
//
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <vector>
 
#include <ddc/ddc.hpp>
 
#include "spline_boundary_conditions.hpp"
 
namespace ddc {
 
template <class BSplines, ddc::BoundCond BcXmin, ddc::BoundCond BcXmax>
class KnotsAsInterpolationPoints
{
    static_assert(BcXmin != ddc::BoundCond::GREVILLE);
    static_assert(BcXmax != ddc::BoundCond::GREVILLE);
 
    using tag_type = typename BSplines::tag_type;
 
public:
    template <typename Sampling, typename U = BSplines>
    static auto get_sampling()
    {
        if constexpr (U::is_uniform()) {
            return std::get<0>(Sampling::
                                       init(ddc::discrete_space<BSplines>().rmin(),
                                            ddc::discrete_space<BSplines>().rmax(),
                                            ddc::DiscreteVector<Sampling>(
                                                    ddc::discrete_space<BSplines>().ncells() + 1)));
        } else {
            using SamplingImpl = typename Sampling::template Impl<Sampling, Kokkos::HostSpace>;
            std::vector<double> knots(ddc::discrete_space<BSplines>().npoints());
            for (int i(0); i < ddc::discrete_space<BSplines>().npoints(); ++i) {
                knots[i] = ddc::discrete_space<BSplines>().get_knot(i);
            }
            return SamplingImpl(knots);
        }
    }
 
    using interpolation_mesh_type = std::conditional_t<
            is_uniform_bsplines_v<BSplines>,
            ddc::UniformPointSampling<tag_type>,
            ddc::NonUniformPointSampling<tag_type>>;
 
    template <typename Sampling>
    static ddc::DiscreteDomain<Sampling> get_domain()
    {
        int const npoints = ddc::discrete_space<BSplines>().ncells() + !BSplines::is_periodic();
        return ddc::DiscreteDomain<Sampling>(
                ddc::DiscreteElement<Sampling>(0),
                ddc::DiscreteVector<Sampling>(npoints));
    }
};
} // namespace ddc