postprocessor.h

Go to the documentation of this file.

//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// Copyright (C) 2020 - 2026 by the ryujin authors
//
 
#pragma once
 
#include <compile_time_options.h>
 
#include "mpi_ensemble.h"
#include "observer_pointer.h"
#include "offline_data.h"
 
#include <deal.II/base/parameter_acceptor.h>
 
namespace ryujin
{
  template <typename Description, int dim, typename Number = double>
  class Postprocessor final : public dealii::ParameterAcceptor
  {
  public:
 
    using HyperbolicSystem = typename Description::HyperbolicSystem;
    using ParabolicSystem = typename Description::ParabolicSystem;
 
    using View = typename HyperbolicSystem::template View<dim, Number>;
 
    static constexpr auto problem_dimension = View::problem_dimension;
 
    using state_type = typename View::state_type;
 
    template <typename T>
    using grad_type = dealii::Tensor<1, dim, T>;
 
    template <typename T>
    using curl_type = dealii::Tensor<1, dim == 2 ? 1 : dim, T>;
 
    using StateVector = typename View::StateVector;
 
 
 
    Postprocessor(const MPIEnsemble &mpi_ensemble,
                  const OfflineData<dim, Number> &offline_data,
                  const HyperbolicSystem &hyperbolic_system,
                  const ParabolicSystem &parabolic_system,
                  const std::string &subsection = "/Postprocessor");
 
    void prepare();
 
 
 
    void compute(const StateVector &state_vector) const;
 
    void reset_bounds() const
    {
      bounds_.clear();
    }
 
 
 
    unsigned int n_quantities() const
    {
      return quantities_.size();
    }
 
    const std::vector<std::string> component_names() const
    {
      return component_names_;
    }
 
    ACCESSOR_READ_ONLY(quantities)
 
  private:
 
 
    bool recompute_bounds_;
    Number beta_;
 
    std::vector<std::string> schlieren_quantities_;
    std::vector<std::string> vorticity_quantities_;
 
 
 
    const MPIEnsemble &mpi_ensemble_;
 
    dealii::ObserverPointer<const OfflineData<dim, Number>> offline_data_;
    dealii::ObserverPointer<const HyperbolicSystem> hyperbolic_system_;
    dealii::ObserverPointer<const ParabolicSystem> parabolic_system_;
 
    std::vector<std::string> component_names_;
    std::vector<std::pair<bool /*primitive*/, unsigned int>> schlieren_indices_;
    std::vector<std::pair<bool /*primitive*/, unsigned int>> vorticity_indices_;
 
    mutable std::vector<std::pair<Number, Number>> bounds_;
    using ScalarHostVector = Vectors::ScalarHostVector<Number>;
    mutable std::vector<ScalarHostVector> quantities_;
 
  };
 
} // namespace ryujin