knots_as_interpolation_points.hpp

// Copyright (C) The DDC development team, see COPYRIGHT.md file
//
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <tuple>
#include <type_traits>
#include <vector>
 
#include <ddc/ddc.hpp>
 
#include <Kokkos_Core.hpp>
 
#include "bsplines_uniform.hpp"
#include "knot_discrete_dimension_type.hpp"
#include "spline_boundary_conditions.hpp"
 
namespace ddc {
 
template <class BSplines, ddc::BoundCond BcLower, ddc::BoundCond BcUpper>
class KnotsAsInterpolationPoints
{
    static_assert(BcLower != ddc::BoundCond::GREVILLE);
    static_assert(BcUpper != ddc::BoundCond::GREVILLE);
 
    using continuous_dimension_type = typename BSplines::continuous_dimension_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());
            ddc::DiscreteDomain<knot_discrete_dimension_t<BSplines>> break_point_domain(
                    ddc::discrete_space<BSplines>().break_point_domain());
            ddc::host_for_each(
                    break_point_domain,
                    [&](ddc::DiscreteElement<knot_discrete_dimension_t<BSplines>> ik) {
                        knots[ik - break_point_domain.front()] = ddc::coordinate(ik);
                    });
            return SamplingImpl(knots);
        }
    }
 
    using interpolation_discrete_dimension_type = std::conditional_t<
            is_uniform_bsplines_v<BSplines>,
            ddc::UniformPointSampling<continuous_dimension_type>,
            ddc::NonUniformPointSampling<continuous_dimension_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