parsed_data_out.h

Go to the documentation of this file.

//-----------------------------------------------------------
//
//    Copyright (C) 2015 by the deal2lkit authors
//
//    This file is part of the deal2lkit library.
//
//    The deal2lkit library 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 2.1 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 deal2lkit distribution.
//
//-----------------------------------------------------------

#ifndef _d2k_parsed_data_out_h
#define _d2k_parsed_data_out_h

#include <deal2lkit/config.h>
#include <fstream>

#include <deal.II/base/config.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/grid/tria.h>
#include <deal.II/numerics/data_out.h>

#include <deal.II/base/logstream.h>
#include <deal.II/base/parameter_handler.h>

#include <deal2lkit/parameter_acceptor.h>
#include <deal2lkit/utilities.h>

D2K_NAMESPACE_OPEN


template <int dim, int spacedim=dim>
class ParsedDataOut : public ParameterAcceptor
{
public:
  ParsedDataOut (const std::string &name="",
                 const std::string &output_format="vtu",
                 const unsigned int &subdivisions=1,
                 const std::string &incremental_run_prefix="",
                 const std::string &base_name_input="solution",
                 const std::string &files_to_save="",
                 const MPI_Comm &comm=MPI_COMM_WORLD);

  virtual void declare_parameters(ParameterHandler &prm);

  virtual void parse_parameters_call_back();

  void prepare_data_output(const DoFHandler<dim, spacedim> &dh,
                           const std::string &suffix="");

  template<typename VECTOR>
  void add_data_vector(const VECTOR &data_vector, const std::string &desc);


  template<typename VECTOR>
  void add_data_vector(const VECTOR &data_vector, const DataPostprocessor<spacedim> &postproc);


  void write_data_and_clear(const Mapping<dim,spacedim> &mapping=StaticMappingQ1<dim,spacedim>::mapping);

private:
  bool initialized;

  const MPI_Comm &comm;

  const unsigned int n_mpi_processes;

  const unsigned int this_mpi_process;

  std::string path_solution_dir;

  std::string output_format;

  unsigned int subdivisions;

  std::string base_name;

  std::string incremental_run_prefix;

  std::string files_to_save;

  std::string solution_names;

  std::string current_name;

  bool output_partitioning;

  std::ofstream output_file;

  shared_ptr<DataOut<dim, DoFHandler<dim, spacedim> > > data_out;
};


// ============================================================
// Template specializations
// ============================================================

template <int dim, int spacedim>
template<typename VECTOR>
void ParsedDataOut<dim,spacedim>::add_data_vector(const VECTOR &data_vector,
                                                  const std::string &desc)
{
  AssertThrow(initialized, ExcNotInitialized());
  deallog.push("AddingData");
  std::vector<std::string> dd = Utilities::split_string_list(desc);
  if (data_out->default_suffix() != "")
    {
      if (dd.size() ==1 )
        {
          data_out->add_data_vector (data_vector, desc);
        }
      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<DataComponentInterpretation::DataComponentInterpretation>
          data_component_interpretation;

          for (; iit !=occurrances.end(); ++iit, ++sit)
            {
              if (*iit > 1)
                data_component_interpretation.push_back(DataComponentInterpretation::component_is_part_of_vector);
              else
                data_component_interpretation.push_back(DataComponentInterpretation::component_is_scalar);
            }

          data_out->add_data_vector (data_vector, dd, DataOut<dim, DoFHandler<dim, spacedim> >::type_dof_data,
                                     data_component_interpretation);

        }
      deallog << "Added data: " << desc << std::endl;
    }
  deallog.pop();
}


template <int dim, int spacedim>
template<typename VECTOR>
void ParsedDataOut<dim,spacedim>::add_data_vector(const VECTOR &data_vector,
                                                  const DataPostprocessor<spacedim> &postproc)
{
  AssertThrow(initialized, ExcNotInitialized());
  data_out->add_data_vector(data_vector,postproc);
}

D2K_NAMESPACE_CLOSE

#endif