lateral_averaging.h

Go to the documentation of this file.

// ------------------------------------------------------
//
// SPDX-License-Identifier: GPL-2.0-or-later
//
// SPDX-FileCopyrightText: Copyright (C) 2011-2025 by the ASPECT authors.
//
// This file is part of ASPECT.
//
// Detailed license information governing the source code and
// contributions can be found in the folder LICENSES and in
// LICENSE and CONTRIBUTING.md at the top level directory.
//
// ------------------------------------------------------


#ifndef _aspect_lateral_averaging_h
#define _aspect_lateral_averaging_h

#include <aspect/simulator_access.h>

#include <deal.II/fe/fe_values.h>

namespace aspect
{
  namespace internal
  {
    template <int dim>
    class FunctorBase
    {
      public:
        virtual
        bool
        need_material_properties() const;

        virtual
        void
        create_additional_material_model_outputs (const unsigned int n_points,
                                                  MaterialModel::MaterialModelOutputs<dim> &outputs) const;

        virtual
        void
        setup(const unsigned int q_points);

        virtual
        void
        operator()(const MaterialModel::MaterialModelInputs<dim> &in,
                   const MaterialModel::MaterialModelOutputs<dim> &out,
                   const FEValues<dim> &fe_values,
                   const LinearAlgebra::BlockVector &solution,
                   std::vector<double> &output) = 0;

        virtual
        ~FunctorBase();
    };
  }

  template <int dim>
  class LateralAveraging : public SimulatorAccess<dim>
  {
    public:
      std::vector<std::vector<double>>
      compute_lateral_averages(const unsigned int n_slices,
                               const std::vector<std::string> &property_names) const;

      std::vector<std::vector<double>>
      compute_lateral_averages(const std::vector<double> &depth_bounds,
                               const std::vector<std::string> &property_names) const;

      std::vector<std::vector<double>>
      compute_lateral_averages(const std::vector<double> &depth_bounds,
                               std::vector<std::unique_ptr<internal::FunctorBase<dim>>> &functors) const;

      void
      get_density_averages(std::vector<double> &values) const;

      void
      get_temperature_averages(std::vector<double> &values) const;

      void
      get_composition_averages(const unsigned int composition_index,
                               std::vector<double> &values) const;

      void
      get_viscosity_averages(std::vector<double> &values) const;

      void
      get_log_viscosity_averages(std::vector<double> &values) const;

      void
      get_velocity_magnitude_averages(std::vector<double> &values) const;

      void
      get_sinking_velocity_averages(std::vector<double> &values) const;

      void
      get_rising_velocity_averages(std::vector<double> &values) const;

      void
      get_Vs_averages(std::vector<double> &values) const;

      void
      get_Vp_averages(std::vector<double> &values) const;

      void
      get_vertical_heat_flux_averages(std::vector<double> &values) const;

      void
      get_vertical_mass_flux_averages(std::vector<double> &values) const;
  };
}


#endif