hawp_gradient_operator.hpp

Go to the documentation of this file.

#pragma once

#include "../types.hpp"

#include "hawp_commons.hpp"
#include "hawp_gradient_evaluator.hpp"
#include "shapes/shape_extension_cache.hpp"


namespace waveblocks {
    namespace wavepackets {
        template<dim_t D, class MultiIndex>
        class HaWpGradient : public AbstractScalarHaWpBasis<D,MultiIndex>
        {
        public:
            class Component : public AbstractScalarHaWp<D,MultiIndex>
            {
            public:
                Component(HaWpGradient const * const owner)
                    : owner_(owner)
                { }

                real_t eps() const override
                {
                    return owner_->eps();
                }

                HaWpParamSet<D> const& parameters() const override
                {
                    return owner_->parameters();
                }

                shapes::ShapeEnumSharedPtr<D,MultiIndex> shape() const override
                {
                    return owner_->shape();
                }

                Coefficients & coefficients()
                {
                    return coefficients_;
                }

                Coefficients const& coefficients() const
                {
                    return coefficients_;
                }

            private:
                HaWpGradient const * const owner_;

                Coefficients coefficients_;
            };

            HaWpGradient()
                : components_(D, Component(this))
            { }

            real_t & eps()
            {
                return eps_;
            }

            real_t eps() const override
            {
                return eps_;
            }

            HaWpParamSet<D> & parameters()
            {
                return parameters_;
            }

            HaWpParamSet<D> const& parameters() const override
            {
                return parameters_;
            }

            shapes::ShapeEnumSharedPtr<D,MultiIndex> & shape()
            {
                return shape_;
            }

            shapes::ShapeEnumSharedPtr<D,MultiIndex> shape() const override
            {
                return shape_;
            }

            Component & component(std::size_t n)
            {
                return components_[n];
            }

            Component const& component(std::size_t n) const
            {
                return components_[n];
            }

            Component & operator[](std::size_t n)
            {
                return component(n);
            }

            Component const& operator[](std::size_t n) const
            {
                return component(n);
            }

            std::size_t n_components() const
            {
                return components_.size();
            }

            template<int N>
            CArray<Eigen::Dynamic,N> evaluate(CMatrix<D,N> const& grid) const
            {
                ScalarHaWp<D,MultiIndex> scalarwp;

                scalarwp.eps() = eps();
                scalarwp.parameters() = parameters();
                scalarwp.shape() = shape();

                std::vector< complex_t const* > coeffs_list(n_components());

                for (std::size_t n = 0; n < n_components(); n++) {
                    coeffs_list[n] = component(n).coefficients().data();
                }

                return scalarwp.template create_evaluator<N>(grid).vector_reduce(coeffs_list.data(), n_components());
            }

            template<int N>
            CArray<Eigen::Dynamic,N> evaluate(RMatrix<D,N> const& rgrid) const
            {
                CMatrix<D,N> cgrid = rgrid.template cast<complex_t>();
                return evaluate(cgrid);
            }

        private:
            real_t eps_;
            HaWpParamSet<D> parameters_;
            shapes::ShapeEnumSharedPtr<D,MultiIndex> shape_;
            std::vector<Component> components_;
        };

        template<dim_t D, class MultiIndex>
        class HaWpGradientOperator
        {
        public:
            HaWpGradient<D,MultiIndex> operator()(AbstractScalarHaWp<D,MultiIndex> const& wp) const
            {
                HaWpGradient<D,MultiIndex> gradwp;
                gradwp.eps() = wp.eps();
                gradwp.parameters() = wp.parameters();
                gradwp.shape() = wp.extended_shape();

                HaWpGradientEvaluator<D,MultiIndex> evaluator(wp.eps(), &wp.parameters(), wp.shape().get(), gradwp.shape().get());
                std::array<Coefficients, std::size_t(D) > coeffs_result = evaluator.apply(wp.coefficients());

                for (dim_t c = 0; c < D; c++) {
                    gradwp[c].coefficients() = std::move(coeffs_result[c]);
                }

                return gradwp;
            }
        };
    }
}