data_out.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2022 by Luca Heltai
//
// This file is part of the FSI-suite platform, based on the deal.II library.
//
// The FSI-suite platform is free software; you can use it, redistribute it,
// and/or modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 3.0 of the License,
// or (at your option) any later version. The full text of the license can be
// found in the file LICENSE at the top level of the FSI-suite platform
// distribution.
//
// ---------------------------------------------------------------------
 
#ifndef parsed_tools_data_out_h
#define parsed_tools_data_out_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/logstream.h>
#include <deal.II/base/mpi.h>
#include <deal.II/base/parameter_acceptor.h>
 
#include <deal.II/dofs/dof_handler.h>
 
#include <deal.II/fe/mapping_q1.h>
 
#include <deal.II/grid/tria.h>
 
#include <deal.II/numerics/data_out.h>
 
#include <filesystem>
#include <fstream>
 
#include "parsed_tools/enum.h"
 
namespace ParsedTools
{
  template <int dim, int spacedim = dim>
  class DataOut : public dealii::ParameterAcceptor
  {
  public:
    DataOut(const std::string  &section_name             = "",
            const std::string  &base_name                = "solution",
            const std::string  &output_format            = "vtu",
            const unsigned int &subdivisions             = 0,
            const bool         &write_higher_order_cells = true,
            const MPI_Comm     &comm                     = MPI_COMM_WORLD);
 
    void
    attach_dof_handler(const dealii::DoFHandler<dim, spacedim> &dh,
                       const std::string                       &suffix = "");
 
    template <typename VECTOR>
    void
    add_data_vector(
      const VECTOR      &data_vector,
      const std::string &desc,
      const typename dealii::DataOut<dim, spacedim>::DataVectorType &type =
        dealii::DataOut<dim, spacedim>::type_automatic);
 
    template <typename VECTOR>
    void
    add_data_vector(const VECTOR                              &data_vector,
                    const dealii::DataPostprocessor<spacedim> &postproc);
 
 
    void
    write_data_and_clear(const dealii::Mapping<dim, spacedim> &mapping =
                           dealii::StaticMappingQ1<dim, spacedim>::mapping);
 
    void
    clear_pvd_record();
 
  private:
    const std::string component_names;
 
    const MPI_Comm &comm;
 
    const unsigned int n_mpi_processes;
 
    const unsigned int this_mpi_process;
 
    std::string output_format;
 
    unsigned int subdivisions;
 
    bool write_higher_order_cells;
 
    std::string base_name;
 
    std::string current_directory;
 
    std::string current_filename;
 
    std::string master_name;
 
    std::string current_name;
 
    bool output_partitioning;
 
    bool output_material_ids;
 
    std::ofstream output_file;
 
    std::unique_ptr<dealii::DataOut<dim, spacedim>> data_out;
 
    typename dealii::DataOut<dim, spacedim>::CurvedCellRegion
      curved_cells_region = dealii::DataOut<dim, spacedim>::curved_inner_cells;
 
    std::vector<std::pair<double, std::string>> pvd_record;
  };
 
 
  // ============================================================
  // Template specializations
  // ============================================================
 
  template <int dim, int spacedim>
  template <typename VECTOR>
  void
  DataOut<dim, spacedim>::add_data_vector(
    const VECTOR                                                  &data_vector,
    const std::string                                             &desc,
    const typename dealii::DataOut<dim, spacedim>::DataVectorType &type)
  {
    std::vector<std::string> dd = dealii::Utilities::split_string_list(desc);
    if (data_out->default_suffix() != "")
      {
        if (dd.size() == 1)
          {
            data_out->add_data_vector(data_vector, desc, type);
          }
        else
          {
            std::vector<std::string>::iterator sit = dd.begin();
            std::vector<int>                   occurrances;
 
            for (; sit != dd.end(); ++sit)
              occurrances.push_back(std::count(dd.begin(), dd.end(), *sit));
 
            std::vector<int>::iterator iit = occurrances.begin();
            sit                            = dd.begin();
 
            std::vector<
              dealii::DataComponentInterpretation::DataComponentInterpretation>
              data_component_interpretation;
 
            for (; iit != occurrances.end(); ++iit, ++sit)
              {
                if (*iit > 1)
                  data_component_interpretation.push_back(
                    dealii::DataComponentInterpretation::
                      component_is_part_of_vector);
                else
                  data_component_interpretation.push_back(
                    dealii::DataComponentInterpretation::component_is_scalar);
              }
 
            data_out->add_data_vector(data_vector,
                                      dd,
                                      type,
                                      data_component_interpretation);
          }
      }
  }
 
 
  template <int dim, int spacedim>
  template <typename VECTOR>
  void
  DataOut<dim, spacedim>::add_data_vector(
    const VECTOR                              &data_vector,
    const dealii::DataPostprocessor<spacedim> &postproc)
  {
    data_out->add_data_vector(data_vector, postproc);
  }
 
} // namespace ParsedTools
 
#endif