postprocessor.h

Go to the documentation of this file.

//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// Copyright (C) 2020 - 2024 by the ryujin authors
//
 
#pragma once
 
#include <compile_time_options.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 View =
        typename Description::template HyperbolicSystemView<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;
 
    using ScalarVector = Vectors::ScalarVector<Number>;
 
 
 
    Postprocessor(const MPI_Comm &mpi_communicator,
                  const HyperbolicSystem &hyperbolic_system,
                  const OfflineData<dim, Number> &offline_data,
                  const std::string &subsection = "/Postprocessor");
 
    void prepare();
 
    unsigned int n_quantities() const
    {
      return quantities_.size();
    }
 
    const std::vector<std::string> component_names() const
    {
      return component_names_;
    }
 
    void reset_bounds() const
    {
      bounds_.clear();
    }
 
    void compute(const StateVector &state_vector) const;
 
    ACCESSOR_READ_ONLY(quantities)
 
 
  private:
 
    bool recompute_bounds_;
    Number beta_;
 
    std::vector<std::string> schlieren_quantities_;
    std::vector<std::string> vorticity_quantities_;
 
 
 
    const MPI_Comm &mpi_communicator_;
 
    dealii::SmartPointer<const HyperbolicSystem> hyperbolic_system_;
    dealii::SmartPointer<const OfflineData<dim, Number>> offline_data_;
 
    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_;
    mutable std::vector<ScalarVector> quantities_;
  };
 
} // namespace ryujin