gsParaviewUtils.h

Go to the documentation of this file.

 
#pragma once
 
// #include <gismo.h>
#include <gsCore/gsForwardDeclarations.h>
#include <gsMSplines/gsMappedBasis.h>   // Only to make linker happy
#include <gsCore/gsDofMapper.h>         // Only to make linker happy
#include <gsAssembler/gsExprHelper.h>  
#include <gsAssembler/gsExprEvaluator.h>
// #include <gsIO/gsIOUtils.h>
 
 
 
#define VTK_BEZIER_QUADRILATERAL 77
 
namespace gismo
{
    template <class T>
    std::vector<std::string> toVTK(const gsFunctionSet<T>& funSet,
                                   unsigned nPts = 1000,
                                   unsigned precision = 5,
                                   std::string label = "",
                                   const bool& export_base64 = false);
 
 
    template <class T>
    std::vector<std::string> toVTK(const gsField<T>& field,
                                   unsigned nPts = 1000,
                                   unsigned precision = 5,
                                   std::string label = "",
                                   const bool& export_base64 = false);
 
 
    template <class MatrixType>
    std::string toDataArray(const MatrixType & matrix,
                            std::map<std::string, std::string> attributes={{"",""}},
                            unsigned precision = 5,
                            const bool& export_base64=false);
 
    template <class E>
    std::vector<std::string> toVTK(const expr::_expr<E>& expr,
                                   gsExprEvaluator<> * evaltr,
                                   unsigned nPts = 1000,
                                   unsigned precision = 5,
                                   std::string label = "SolutionField",
                                   const bool& export_base64 = false)
    {
        std::vector<std::string> out;
 
        // if false, embed topology ?
        const index_t n = evaltr->exprData()->multiBasis().nBases();
 
        gsMatrix<real_t> evaluated_values, bounding_box_dimensions;
 
        for (index_t i = 0; i != n; ++i) {
            // Get bounding box and sample evaluation points on current patch
            bounding_box_dimensions =
                evaltr->exprData()->multiBasis().piece(i).support();
            gsGridIterator<real_t, CUBE> grid_iterator(bounding_box_dimensions,
                                                    nPts);
            evaltr->eval(expr, grid_iterator, i);
 
            // Evaluate Expression on grid_points
            evaluated_values = evaltr->allValues(
                evaltr->elementwise().size() / grid_iterator.numPoints(),
                grid_iterator.numPoints());
 
 
            GISMO_ASSERT(evaluated_values.rows() <= 3, "The expression can be scalar or have at most 3 components.");
            if (evaluated_values.rows() == 2)
                // Pad matrix with zeros
                evaluated_values.conservativeResizeLike(gsEigen::MatrixXd::Zero(3,evaluated_values.cols()));
            
            out.push_back(toDataArray(evaluated_values,{{"Name",label}}, precision,export_base64));
 
        }
        return out;
    }
 
 
 
 
 
    GISMO_EXPORT gsMatrix<real_t> vtkIDTransform(index_t nU, index_t nV);
 
 
 
    GISMO_EXPORT std::string toDataArray(index_t num, std::map<std::string, std::string> attributes={{"",""}});
 
 
 
    template<class T>
    std::string BezierVTK(const gsMultiPatch<T> & mPatch);
} // namespace gismo
 
#undef VTK_BEZIER_QUADRILATERAL
 
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsParaviewUtils.hpp)
#endif