vertex_list.hpp

Go to the documentation of this file.

#ifndef VERTEX_LIST_HPP
#define VERTEX_LIST_HPP

#include "space_settings.hpp"

template<typename Device, typename F>
int get_starts_and_ends(int n, F condition, View<bool*, CLayout, HostType>& starts_h, View<bool*, CLayout, HostType>& ends_h){
    View<bool*, CLayout, Device> starts(NoInit("starts"), n);
    View<bool*, CLayout, Device> ends(NoInit("ends"), n);

    // First, determine which vertices go on the list
    View<bool*, CLayout, Device> is_in(NoInit("is_in"), n);
    Kokkos::parallel_for("check_condition", Kokkos::RangePolicy<typename Device::execution_space>(0, n), KOKKOS_LAMBDA(const int i){
        is_in(i) = condition(i);
    });

    // Next, subtract to get list starts and stops
    int nranges = 0;
    Kokkos::parallel_reduce("check_condition", Kokkos::RangePolicy<typename Device::execution_space>(0, n), KOKKOS_LAMBDA(const int i, int& nranges_l){
        starts(i) = false;
        ends(i) = false;
        if(is_in(i)){
            if(i==n-1){
                ends(i) = true;
                nranges_l++;
            }else{
                if(!is_in(i+1)){ // List just ended
                    ends(i) = true;
                    nranges_l++;
                }
            }

            if(i==0){
                 starts(i) = true;
            }else{
                if(!is_in(i-1)){ // List just started
                    starts(i) = true;
                }
            }
        }
    }, nranges);

    ends_h = View<bool*, CLayout, HostType>(NoInit("ends"), n);
    starts_h = View<bool*, CLayout, HostType>(NoInit("starts"), n);
    Kokkos::deep_copy(ends_h, ends);
    Kokkos::deep_copy(starts_h, starts);

    return nranges;
}

// A compressed way to represent a list of vertices.
// Note: using C/python convention so range {0, 2} means vertices 0 and 1
class VertexList{
    struct IntegerRange{
        int start;
        int end; // Note: using C/python convention so range {0, 2} means vertices 0 and 1

        KOKKOS_INLINE_FUNCTION bool is_in_range(int i) const{
            return (i>=start && i<end);
        }

        KOKKOS_INLINE_FUNCTION int size() const{
            return (end - start);
        }
    };
    public:
    View<IntegerRange*,CLayout,HostType> ranges;

    public:

    VertexList()
      : ranges("ranges", 0)
    {}

    // Initialize with single range
    VertexList(int start, int end);

    // Initialize with a condition, e.g.:
    //     VertexList(grid.nnode, KOKKOS_LAMBDA( const int i){return grid_h.is_in_psi_range(i)});
    template<typename F>
    VertexList(int n, F condition){
        View<bool*, CLayout, HostType> starts_h;
        View<bool*, CLayout, HostType> ends_h;
        int nranges = get_starts_and_ends<DeviceType>(n, condition, starts_h, ends_h);
        ranges = View<IntegerRange*,CLayout,HostType>(NoInit("ranges"), nranges);

        // Now populate views
        int i_range = 0;
        for(int i=0; i<n; i++){
            if(starts_h(i)){
                ranges(i_range).start = i;
            }
            if(ends_h(i)){
                ranges(i_range).end = i+1; // i is included, therefore the list ends at i+1
                i_range += 1;
            }
        }
    }

    // Initialize the list by passing in the full uncompressed list of vertices.
    VertexList(const View<int*,CLayout,HostType>& unordered_full_list, bool one_indexed);

    KOKKOS_INLINE_FUNCTION bool is_in_list(int i) const {
        // First check ranges
        for (int is=0; is<ranges.size(); is++){
            if(ranges(is).is_in_range(i)) return true;
        }

        return false;
    }

    // Number of vertices
    KOKKOS_INLINE_FUNCTION int size() const{
        int n = 0;

        // Add ranges
        for (int is=0; is<ranges.size(); is++){
            n += ranges(is).size();
        }

        return n;
    }

    template<typename DeviceExSpace, typename F>
    inline void for_all(const std::string label, F lambda_func) const {
        // Loop through ranges
        for (int is=0; is<ranges.size(); is++){
            Kokkos::parallel_for(label, Kokkos::RangePolicy<DeviceExSpace>(ranges(is).start, ranges(is).end), lambda_func);
        }
    }

    template<class Device>
    void pack_contiguous(const View<double*, CLayout, Device>& input, const View<double*, CLayout, Device>& contiguous) const;

    template<class Device>
    void unpack_contiguous(const View<double*, CLayout, Device>& contiguous, const View<double*, CLayout, Device>& output) const;

    VertexList operator&(const VertexList& list2) const;

    VertexList& operator|=(const VertexList& rhs); // Custom +=

    void batch(int first_val, int nvals, const View<int*, CLayout, HostType>& view) const;

    int min() const;

    bool is_contiguous() const;

    void print(const std::string& msg) const;

    bool is_subset(const VertexList& list2) const;

    bool intersects(const VertexList& list2) const;

    bool intersects(int start, int end) const;

    template<typename T>
    void set_to_value(const T& view, double value) const{
        for_all<typename T::execution_space>("vertex_list_set_to_value", KOKKOS_LAMBDA(const int i){
            view(i) = value;
        });
        Kokkos::fence();
    }

    template<typename T, typename F>
    void set_to_value(const T& view, F func) const{
        for_all<typename T::execution_space>("vertex_list_set_to_value", KOKKOS_LAMBDA(const int i){
            view(i) = func(i);
        });
        Kokkos::fence();
    }

    template<class Device>
    View<int*, CLayout, Device> get_view_int_not_in_list(int nnode_in) const{
        View<int*, CLayout, Device> view(NoInit("is_inside"), nnode_in);
        // Set all values to 1
        Kokkos::deep_copy(view, 1);

        // Set values inside list to 0
        for_all<typename Device::execution_space>("set_is_inside", KOKKOS_LAMBDA(const int i){
            view(i) = 0;
        }); 
        Kokkos::fence();

        return view;
    }
};

#endif