gsAdaptiveMeshingCompare.h

/*
#pragma once


#include <iostream>
#include <gsHSplines/gsHBoxUtils.h>

namespace gismo
{


template <short_t d, class T>
class gsHBoxCheck
{
public:
    virtual ~gsHBoxCheck() {};

    virtual bool check(const gsHBox<d,T> & box) const = 0;
};

template <short_t d, class T>
class gsMinLvlCompare : public gsHBoxCheck<d,T>
{
public:
    explicit gsMinLvlCompare(index_t minlevel = 0)
    :
    m_minLevel(minlevel)
    {}

    bool check(const gsHBox<d,T> & box) const { return box.level() > m_minLevel; }

protected:
    index_t m_minLevel;
};

template <short_t d, class T>
class gsMaxLvlCompare : public gsHBoxCheck<d,T>
{
public:
    explicit gsMaxLvlCompare(index_t maxLevel)
    :
    m_maxLevel(maxLevel)
    {}

    bool check(const gsHBox<d,T> & box) const { return box.level() < m_maxLevel; }

protected:
    index_t m_maxLevel;
};

template <short_t d, class T>
class gsSmallerErrCompare : public gsHBoxCheck<d,T>
{
public:
    gsSmallerErrCompare(const T & threshold)
    :
    m_threshold(threshold)
    {}

    bool check(const gsHBox<d,T> & box) const { return box.error() < m_threshold; }

protected:
    T m_threshold;
};

template <short_t d, class T>
class gsLargerErrCompare : public gsHBoxCheck<d,T>
{
public:
    gsLargerErrCompare(const T & threshold)
    :
    m_threshold(threshold)
    {}

    bool check(const gsHBox<d,T> & box) const { return box.error() > m_threshold; }

protected:
    T m_threshold;
};

template <short_t d, class T>
class gsOverlapCompare : public gsHBoxCheck<d,T>
{
public:
    gsOverlapCompare(const gsHBoxContainer<d,T> & markedRef, index_t m) //, patchHContainer & markedCrs
    :
    m_m(m)
    {
        gsHBoxContainer<d,T> tmp(markedRef);
        m_markedRefChildren = gsHBoxUtils<d,T>::Unique(tmp.getChildren());
    }

    bool check(const gsHBox<d,T> & box) const
    {
        // We are going to check if the coarsening extension (closely related to the coarsening neighborhood) of the parent of \a box (since it will be elevated) fulfills the conditions of an empty coarsening neighborhood, as well as the condition of an empty coasening neighborhood provided that there is no element that will be refined herein.
        bool clean = true;

        // if (m_m>=2) // admissiblity part
        // {
            // 1) Check if the coarsening neighborhood is empty
            gsHBox<d,T> parent = box.getParent();
            typename gsHBox<d,T>::Container Cextension = parent.getCextension(m_m);
            Cextension = gsHBoxUtils<d,T>::Unique(Cextension);

            for (typename gsHBox<d,T>::Iterator it = Cextension.begin(); it != Cextension.end() && clean; it++)
            {
                it->computeCenter();
                clean &=
                        // the level is even larger (i.e. even higher decendant); then it is not clean
                            (!((it->levelInCenter()>=it->level()))
                        )
                        ;
            }

            if (!clean) return clean;
        // }

        // 2) Now we check if the parents of any of the cells in the extensions overlap with the marked cells. If so, it would cause a problem with the coarsening.
        typename gsHBox<d,T>::Container  intersection = gsHBoxUtils<d,T>::ContainedIntersection(Cextension,m_markedRefChildren);
        clean = intersection.size()==0;
        return clean;
    }

protected:
    typename gsHBox<d,T>::Container m_markedRefChildren;
    index_t m_m;
};


} // namespace gismo