grid_weights.hpp

Go to the documentation of this file.

#ifndef GRID_WEIGHTS_HPP
#define GRID_WEIGHTS_HPP

#include "globals.hpp"
#include "grid_structs.hpp"
#include "linear_weights.hpp"

// phi weight struct - empty if phi weights are not needed
enum PhiWtUsage{
    PhiWtNeeded,
    PhiIndOnly,
    NoPhi
};

constexpr KOKKOS_INLINE_FUNCTION PhiWtUsage get_phi_wt_usage(PhiInterpType PIT){return (PIT==PhiInterpType::Planes ? PhiWtUsage::PhiWtNeeded : PhiWtUsage::NoPhi);}

template<PhiWtUsage PWU>
struct SimdPhiWeights{
    KOKKOS_INLINE_FUNCTION void set(const Simd<double>& phi_in, double inv_delta_phi, int nplanes){}

    KOKKOS_INLINE_FUNCTION void set_to_midplane(){}
};

template<>
struct SimdPhiWeights<PhiIndOnly>{
    Simd<int> i_phi;

    //KOKKOS_INLINE_FUNCTION void set(const Simd<double>& phi_in, double inv_delta_phi, int nplanes){}
};

template<>
struct SimdPhiWeights<PhiWtNeeded>{
    Simd<LinearWeights> phi;

    KOKKOS_INLINE_FUNCTION void set(const Simd<double>& phi_in, double inv_delta_phi, int nplanes){
        for (int i_simd = 0; i_simd<SIMD_SIZE; i_simd++){
            phi[i_simd].set(phi_in[i_simd], inv_delta_phi, nplanes);
        }
    }

    KOKKOS_INLINE_FUNCTION void set_to_midplane(){
        for (int i_simd = 0; i_simd<SIMD_SIZE; i_simd++){
            phi[i_simd].w[0] = 0.5;
            phi[i_simd].w[1] = 0.5;
        }
    }
};


template<Order OT, PhiInterpType PIT>
struct SimdGridWeights{};


// Weights for zero-order interpolation: just the node index
template<PhiInterpType PIT>
struct SimdGridWeights<Order::Zero, PIT>{
    Simd<int> node;

    // Checks whether node index is >= 0
    KOKKOS_INLINE_FUNCTION bool is_valid(int i_simd) const{
        return (node[i_simd]>=0);
    }

    // Checks whether node index is >= 0
    KOKKOS_INLINE_FUNCTION bool is_invalid(int i_simd) const{
        return (node[i_simd]<0);
    }

    KOKKOS_INLINE_FUNCTION void mark_as_invalid(int i_simd){
        node[i_simd] = -1;
    }
};


// Weights for first-order interpolation: the triangle index and barycentric weights
template<PhiInterpType PIT>
struct SimdGridWeights<Order::One, PIT>{
    Simd<int> itr;
    SimdGridVec p;

    //SimdPhiWeights<get_phi_wt_usage(PIT)> phi_wts;

    KOKKOS_INLINE_FUNCTION SimdGridWeights()
      : itr(-1) // Initialize SimdGridWeights to invalid
    {}

    // Checks whether itr index is >= 0
    KOKKOS_INLINE_FUNCTION bool is_valid(int i_simd) const{
        return (itr[i_simd]>0);
    }

    KOKKOS_INLINE_FUNCTION bool is_invalid(int i_simd) const{
        return (itr[i_simd]<=0);
    }

    KOKKOS_INLINE_FUNCTION void is_not_in_grid(Simd<bool>& is_not_valid) const{
        for (int i_simd = 0; i_simd<SIMD_SIZE; i_simd++){
            is_not_valid[i_simd] = is_invalid(i_simd);
        }
    }

    KOKKOS_INLINE_FUNCTION void mark_as_invalid(){
        itr = -1;
    }

    // From the provided SimdGridWeights object, use its triangle as a hint for the triangle at the next grid search
    KOKKOS_INLINE_FUNCTION void add_hint(const SimdGridWeights<Order::One, PIT>& grid_wts){
        itr = grid_wts.itr;
    }

    // From the provided SimdGridWeights object, use its triangle as a hint for the triangle at the next grid search
    KOKKOS_INLINE_FUNCTION void add_hint(const SimdGridWeights<Order::One, PIT>& grid_wts, int i_simd){
        itr[i_simd] = grid_wts.itr[i_simd];
    }
};

#endif