msh_out.h

#ifndef __MSH_OUT_H__
#define __MSH_OUT_H__

#include <deal.II/numerics/data_out.h>
#include <deal.II/grid/tria.h>

namespace PHiLiP {

namespace GridRefinement {

enum class StorageType{
    node,        
    element,     
    elementNode, 
};

enum class DataType{
    scalar, 
    vector, 
    matrix, 
};


template <int dim>
class MshOutData
{
public:
    virtual ~MshOutData() = default;


    explicit MshOutData(
        StorageType storage_type) :
            storage_type(storage_type){};


    void write_msh_data(
        const dealii::DoFHandler<dim> &dof_handler,
        std::ostream &                 out);

protected:
    StorageType storage_type;


    std::vector<std::string> string_tags;  


    std::vector<double>      real_tags;    


    std::vector<int>         integer_tags; 


    virtual void write_msh_data_internal(
        const dealii::DoFHandler<dim> &dof_handler,
        std::ostream &                 out) = 0;


    unsigned int num_entries(
        const dealii::DoFHandler<dim> &dof_handler);


    void set_string_tags(
        std::string name,
        std::string interpolation_scheme);


    void set_string_tags(
        std::string name);


    void set_real_tags(
        double time);

    // sets the integer tags

    void set_integer_tags(
        unsigned int time_step,
        unsigned int num_components,
        unsigned int num_entries);
};


template <int dim, typename T>
class MshOutDataInternal : public MshOutData<dim>
{
public:

    MshOutDataInternal(
        std::vector<T> data,
        StorageType    storage_type,
        const dealii::DoFHandler<dim> &dof_handler) : 
            MshOutData<dim>(storage_type),
            data(data)
    {
        this->set_integer_tags(0, num_components, this->num_entries(dof_handler));
    };


    MshOutDataInternal(
        std::vector<T>                 data,
        StorageType                    storage_type,
        std::string                    name,
        const dealii::DoFHandler<dim> &dof_handler) :
            MshOutData<dim>(storage_type),
            data(data)
    {
        this->set_integer_tags(0, num_components, this->num_entries(dof_handler));
        this->set_string_tags(name);
    }

protected:

    void write_msh_data_internal(
        const dealii::DoFHandler<dim> &dof_handler,
        std::ostream &                 out) override;

private:

    const std::vector<T> data;


    static const unsigned int num_components;
};


template <int dim, typename real>
class MshOut
{
public: 

    explicit MshOut(
        const dealii::DoFHandler<dim> &dof_handler) :
            dof_handler(dof_handler){};


    template <typename T>
    void add_data_vector(
        std::vector<T> data,
        StorageType    storage_type)
    {
        data_vector.push_back(
            std::make_shared<MshOutDataInternal<dim,T>>(
                data,
                storage_type,
                dof_handler));
    }


    template <typename T>
    void add_data_vector(
        std::vector<T> data,
        StorageType    storage_type,
        std::string    name)
    {
        data_vector.push_back(
            std::make_shared<MshOutDataInternal<dim,T>>(
                data,
                storage_type,
                name,
                dof_handler));
    }


    void write_msh(
        std::ostream &out);

private:
    const dealii::DoFHandler<dim> &               dof_handler; 
    std::vector<std::shared_ptr<MshOutData<dim>>> data_vector; 
};

} // namespace GridRefinement

} //namespace PHiLiP

#endif // __GMSH_OUT_H__