gsAdaptiveMeshingUtils.h

 
#pragma once
 
 
#include <iostream>
 
namespace gismo
{
 
 
template<typename T>
class gsElementErrorPlotter : public gsFunction<T>
{
public:
    gsElementErrorPlotter(const gsBasis<T>& basis, const std::vector<T>& errors ) 
    : m_basis(basis),m_errors(errors)
    { }
 
    virtual void eval_into(const gsMatrix<T>& u, gsMatrix<T>& res) const
    {
        // Initialize domain element iterator -- using unknown 0
        res.setZero(1,u.cols());
        for(index_t i=0; i<u.cols();++i)
        {
            int iter =0;
            // Start iteration over elements
 
            typename gsBasis<T>::domainIter domIt = m_basis.makeDomainIterator();
            for (; domIt->good(); domIt->next() )
            {
                 bool flag = true;
                const gsVector<T>& low = domIt->lowerCorner();
                const gsVector<T>& upp = domIt->upperCorner();
 
 
                for(int d=0; d<domainDim();++d )
                {
                    if(low(d)> u(d,i) || u(d,i) > upp(d))
                    {
                        flag = false;
                        break;
                    }
                }
                if(flag)
                {
                     res(0,i) = m_errors.at(iter);
                     break;
                }
                iter++;
            }
        }
    }
 
    short_t domainDim() const { return m_basis.dim();}
 
private:
    const gsBasis<T>& m_basis;
    const std::vector<T>& m_errors;
};
 
} // namespace gismo