postprocessor.hpp

Go to the documentation of this file.

#pragma once
#include <deal.II/base/exceptions.h>
#include <deal.II/base/mpi.h>
 
#include <deal.II/grid/tria.h>
 
#include <deal.II/lac/generic_linear_algebra.h>
#include <deal.II/lac/la_parallel_block_vector.h>
#include <deal.II/lac/la_parallel_vector.h>
 
#include <deal.II/numerics/data_component_interpretation.h>
 
#include <deal.II/particles/particle.h>
#include <deal.II/particles/particle_handler.h>
 
#include <meltpooldg/post_processing/generic_data_out.hpp>
#include <meltpooldg/post_processing/output_data.hpp>
#include <meltpooldg/time_integration/time_stepping_data.hpp>
#include <meltpooldg/utilities/conditional_ostream.hpp>
 
#include <complex>
#include <string>
#include <utility>
#include <vector>
 
 
// @ todo: !!! clean-up and refactoring !!!
 
namespace MeltPoolDG
{
  template <int dim, typename number>
  class Postprocessor
  {
  public:
    Postprocessor(const MPI_Comm                                   mpi_communicator_in,
                  const OutputData<number>                        &output_data_in,
                  const TimeIntegration::TimeSteppingData<number> &time_data,
                  const dealii::Mapping<dim>                      &mapping_in,
                  const dealii::Triangulation<dim>                &triangulation_in,
                  const ConditionalOStream                        &pcout_in);
 
    void
    process(const int                          n_time_step,
            const GenericDataOut<dim, number> &generic_data_out,
            const number                       time                                    = -1.0,
            const bool                         force_output                            = false,
            const bool                         force_update_requested_output_variables = false);
 
    void
    process(const int                                                 n_time_step,
            const std::function<void(GenericDataOut<dim, number> &)> &attach_output_vectors,
            const number                                              time = -1.0);
 
    void
    process_particles(const int n_time_step, const number time);
 
    inline bool
    is_output_timestep(const int n_time_step, const number time) const
    {
      if (n_time_step == 0)
        return true;
      if (time - time_at_last_output >= output_data.write_time_step_size)
        return true;
      return not(n_time_step % output_data.write_frequency);
    }
 
    template <class Archive>
    void
    serialize(Archive &ar, const unsigned int /*version*/)
    {
      ar &vector_times_and_names;
      ar &time_at_last_output;
    }
 
    void
    register_obstacle_output(
      dealii::Particles::ParticleHandler<dim> const *particle_handler,
      const std::vector<std::string>                &property_names,
      const std::vector<dealii::DataComponentInterpretation::DataComponentInterpretation>
        &property_data_component_interpretation)
    {
      obstacle_output.particle_handler = particle_handler;
      obstacle_output.property_names   = property_names;
      obstacle_output.property_data_component_interpretation =
        property_data_component_interpretation;
    }
 
    template <typename ComplexVectorType>
    void
    output_complex_valued_vector_to_csv(const int                n_time_step,
                                        const number             time,
                                        const ComplexVectorType &output_vector,
                                        const std::string       &filename,
                                        const bool               force_output = false) const;
 
  private:
    const MPI_Comm                    mpi_communicator;
    const OutputData<number>         &output_data;
    const dealii::Mapping<dim>       &mapping;
    const dealii::Triangulation<dim> &triangulation;
    const ConditionalOStream          pcout;
    const bool                        do_simplex;
    const number                      end_time;
    number                            time_at_last_output = 0.0;
 
    struct ObstacleOutput
    {
      const dealii::Particles::ParticleHandler<dim> *particle_handler = nullptr;
      std::vector<std::string>                       property_names;
      std::vector<dealii::DataComponentInterpretation::DataComponentInterpretation>
        property_data_component_interpretation;
    } obstacle_output;
 
    // list of indices for the requested variables
    std::vector<unsigned int> idx_req_vars;
 
    std::vector<std::pair<number, std::string>> vector_times_and_names;
 
    std::vector<std::pair<number, std::string>> particle_times_and_names;
 
    void
    clean_pvd(std::vector<std::pair<number, std::string>> &times_and_names);
 
    void
    write_paraview_files(const unsigned int                 n_time_step,
                         const number                       time,
                         const GenericDataOut<dim, number> &generic_data_out,
                         const bool                         force_output_all = false);
 
    void
    write_particle_paraview_files(const unsigned int n_time_step, const number time);
 
    void
    print_boundary_ids();
  };
 
  // templated function definitions
  template <int dim, typename number>
  template <typename ComplexVectorType>
  void
  MeltPoolDG::Postprocessor<dim, number>::output_complex_valued_vector_to_csv(
    const int                n_time_step,
    const number             time,
    const ComplexVectorType &output_vector,
    const std::string       &filename,
    const bool               force_output) const
  {
    if (not(is_output_timestep(n_time_step, time) or force_output))
      return;
 
    static int file_count = 0;
 
    // Only rank 0 writes the output file to avoid multiple processes writing to the same file in
    // parallel
    if (dealii::Utilities::MPI::this_mpi_process(mpi_communicator) == 0)
      {
        std::string full_filename =
          output_data.directory + '/' + filename + "_" + std::to_string(file_count) + ".csv";
 
        std::ofstream file(full_filename, std::ios::out | std::ios::trunc);
        AssertThrow(file, dealii::ExcMessage("Can not open the file: " + full_filename));
 
        file << "Time: " << time << '\n';
        file << "N time step: " << n_time_step << '\n';
        file << '\n';
        file << "Real part;Imaginary part\n";
 
        for (const auto &v : output_vector)
          file << v.real() << ';' << v.imag() << '\n';
      }
 
    ++file_count;
  }
} // namespace MeltPoolDG