mesh_adaptor.h

Go to the documentation of this file.

//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// Copyright (C) 2024 - 2026 by the ryujin authors
//
 
#pragma once
 
#include <ryujin/base/compile_time_options.h>
#include <ryujin/base/convenience_macros.h>
#include <ryujin/base/mpi_ensemble.h>
#include <ryujin/base/observer_pointer.h>
#include <ryujin/discretization/offline_data.h>
#include <ryujin/interface/postprocessor.h>
#include <ryujin/interface/simulation.h>
#include <ryujin/interface/task.h>
#include <ryujin/linear_algebra/state_vector.h>
 
#include <deal.II/base/parameter_acceptor.h>
 
#include <random>
 
namespace ryujin
{
  enum class AdaptationStrategy {
    global_refinement,
 
    random_adaptation,
 
    smoothness_indicators,
  };
 
  enum class MarkingStrategy {
    fixed_threshold,
  };
} // namespace ryujin
 
#ifndef DOXYGEN
DECLARE_ENUM(
    ryujin::AdaptationStrategy,
    LIST({ryujin::AdaptationStrategy::global_refinement, "global refinement"},
         {ryujin::AdaptationStrategy::random_adaptation, "random adaptation"},
         {ryujin::AdaptationStrategy::smoothness_indicators,
          "smoothness indicators"}, ));
 
DECLARE_ENUM(ryujin::MarkingStrategy,
             LIST({ryujin::MarkingStrategy::fixed_threshold,
                   "fixed threshold"}));
#endif
 
namespace ryujin
{
  template <int dim, typename Number = double>
  class MeshAdaptor final : public dealii::ParameterAcceptor,
                            public Interface::Task<Number>
  {
  public:
 
    MeshAdaptor(Interface::Simulation<dim, Number> &simulation,
                const std::string &subsection = "/MeshAdaptor");
 
 
 
    void prepare(TaskContext<Number> &context) override;
 
    void execute(TaskContext<Number> &context) override;
 
 
  private:
 
    AdaptationStrategy adaptation_strategy_;
    std::uint_fast64_t random_adaptation_mersenne_twister_seed_;
 
    MarkingStrategy marking_strategy_;
    double coarsening_threshold_;
    double refinement_threshold_;
    bool absolute_threshold_;
    unsigned int min_refinement_level_;
    unsigned int max_refinement_level_;
 
    std::vector<std::string> smoothness_selected_quantities_;
    Number smoothness_local_global_ratio_;
    Number smoothness_min_cutoff_;
    Number smoothness_max_cutoff_;
    unsigned int smoothness_widen_stencil_;
 
 
 
    Trigger<Number> trigger_;
 
    Interface::Simulation<dim, Number> &simulation_;
    const MPIEnsemble &mpi_ensemble_;
 
    dealii::ObserverPointer<const OfflineData<dim, Number>> offline_data_;
 
    const Interface::Postprocessor<dim, Number> &postprocessor_;
 
    typename Interface::Postprocessor<dim, Number>::Selection selection_;
 
    /* The computed cell indicators. */
    dealii::Vector<float> indicators_;
 
    /* random adaptation: */
    std::mt19937_64 mersenne_twister_;
 
    /*
     * smoothness indicators: only valid if the "smoothness indicator"
     * refinement strategy has been selected.
     */
    ScalarVector<Number> smoothness_indicators_;
 
 
 
    void analyze(const StateVector<Number> &state_vector);
 
    void mark_cells_for_coarsening_and_refinement();
 
    /* random adaptation: */
    void populate_cell_indicators_with_random_values();
 
    /* smoothness indicators: */
    void populate_cell_indicators_from_smoothness_indicators();
 
    /*
     * Compute smoothness indicators. This function reinitializes and
     * populates the smoothness_indicators_ vector.
     */
    void compute_smoothness_indicators(const StateVector<Number> &state_vector);
 
  };
 
} // namespace ryujin