utilities.h

Go to the documentation of this file.

/*
  Copyright (C) 2011 - 2021 by the authors of the ASPECT code.

  This file is part of ASPECT.

  ASPECT is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2, or (at your option)
  any later version.

  ASPECT is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with ASPECT; see the file LICENSE.  If not see
  <http://www.gnu.org/licenses/>.
*/

#ifndef _aspect_material_model_utilities_h
#define _aspect_material_model_utilities_h

#include <aspect/global.h>
#include <deal.II/base/point.h>
#include <deal.II/base/symmetric_tensor.h>
#include <deal.II/fe/component_mask.h>
#include <deal.II/base/signaling_nan.h>
#include <deal.II/base/parameter_handler.h>

namespace aspect
{
  template <int dim> class SimulatorAccess;

  namespace MaterialModel
  {
    using namespace dealii;

    template <int dim> struct MaterialModelOutputs;
    template <int dim> struct EquationOfStateOutputs;

    namespace MaterialUtilities
    {
      namespace Lookup
      {
        class MaterialLookup
        {
          public:

            double
            specific_heat(const double temperature,
                          const double pressure) const;

            double
            density(const double temperature,
                    const double pressure) const;

            double
            thermal_expansivity(const double temperature,
                                const double pressure) const;

            double
            seismic_Vp(const double temperature,
                       const double pressure) const;

            double
            seismic_Vs(const double temperature,
                       const double pressure) const;

            double
            enthalpy(const double temperature,
                     const double pressure) const;

            double
            dHdT (const double temperature,
                  const double pressure) const;

            double
            dHdp (const double temperature,
                  const double pressure) const;

            std::array<std::pair<double, unsigned int>,2>
            enthalpy_derivatives(const std::vector<double> &temperatures,
                                 const std::vector<double> &pressures,
                                 const unsigned int n_substeps = 1) const;

            double
            dRhodp (const double temperature,
                    const double pressure) const;

            unsigned int
            dominant_phase (const double temperature,
                            const double pressure) const;

            bool
            has_dominant_phase() const;

            std::vector<std::string>
            phase_volume_column_names() const;

            double
            phase_volume_fraction(const int phase_id,
                                  const double temperature,
                                  const double pressure) const;

            std::array<double,2>
            get_pT_steps() const;


            const std::vector<std::string> &
            get_dominant_phase_names() const;

          protected:
            double
            value (const double temperature,
                   const double pressure,
                   const Table<2, double> &values,
                   const bool interpol) const;

            unsigned int
            value (const double temperature,
                   const double pressure,
                   const Table<2, unsigned int> &values) const;

            double get_nT(const double temperature) const;

            double get_np(const double pressure) const;

            ::Table<2,double> density_values;
            ::Table<2,double> thermal_expansivity_values;
            ::Table<2,double> specific_heat_values;
            ::Table<2,double> vp_values;
            ::Table<2,double> vs_values;
            ::Table<2,double> enthalpy_values;
            ::Table<2,unsigned int> dominant_phase_indices;

            std::vector<std::string> phase_column_names;
            std::vector<::Table<2,double>> phase_volume_fractions;

            double delta_press;
            double min_press;
            double max_press;
            double delta_temp;
            double min_temp;
            double max_temp;
            unsigned int n_temperature;
            unsigned int n_pressure;
            unsigned int n_phases;
            unsigned int n_columns;
            bool interpolation;
            bool has_dominant_phase_column;
            std::vector<std::string> dominant_phase_names;
        };

        class HeFESToReader : public MaterialLookup
        {
          public:
            HeFESToReader(const std::string &material_filename,
                          const std::string &derivatives_filename,
                          const bool interpol,
                          const MPI_Comm &comm);
        };

        class PerplexReader : public MaterialLookup
        {
          public:
            PerplexReader(const std::string &filename,
                          const bool interpol,
                          const MPI_Comm &comm);
        };
      }



      std::vector<double>
      compute_composition_fractions(const std::vector<double> &compositional_fields,
                                    const ComponentMask &field_mask = ComponentMask());

      DEAL_II_DEPRECATED
      std::vector<double>
      compute_volume_fractions(const std::vector<double> &compositional_fields,
                               const ComponentMask &field_mask = ComponentMask());

      std::vector<double>
      compute_volumes_from_masses(const std::vector<double> &masses,
                                  const std::vector<double> &densities,
                                  const bool return_as_fraction);

      enum CompositionalAveragingOperation
      {
        harmonic,
        arithmetic,
        geometric,
        maximum_composition
      };



      CompositionalAveragingOperation
      parse_compositional_averaging_operation (const std::string &parameter_name,
                                               const ParameterHandler &prm);



      double average_value (const std::vector<double> &volume_fractions,
                            const std::vector<double> &parameter_values,
                            const CompositionalAveragingOperation &average_type);



      template <int dim>
      void
      fill_averaged_equation_of_state_outputs(const EquationOfStateOutputs<dim> &eos_outputs,
                                              const std::vector<double> &mass_fractions,
                                              const std::vector<double> &volume_fractions,
                                              const unsigned int i,
                                              MaterialModelOutputs<dim> &out);



      namespace PhaseUtilities
      {
        enum PhaseAveragingOperation
        {
          arithmetic,
          logarithmic
        };
      }

      double phase_average_value (const std::vector<double> &phase_function_values,
                                  const std::vector<unsigned int> &n_phases_per_composition,
                                  const std::vector<double> &parameter_values,
                                  const unsigned int composition,
                                  const PhaseUtilities::PhaseAveragingOperation operation = PhaseUtilities::arithmetic);



      template <int dim>
      struct PhaseFunctionInputs
      {
        PhaseFunctionInputs(const double temperature,
                            const double pressure,
                            const double depth,
                            const double pressure_depth_derivative,
                            const unsigned int phase_index);

        double temperature;
        double pressure;
        double depth;
        double pressure_depth_derivative;

        unsigned int phase_index;
      };

      template <int dim>
      class PhaseFunction: public ::aspect::SimulatorAccess<dim>
      {
        public:
          double compute_value (const PhaseFunctionInputs<dim> &in) const;

          double compute_derivative (const PhaseFunctionInputs<dim> &in) const;

          unsigned int n_phase_transitions () const;

          double get_transition_slope (const unsigned int phase_index) const;

          const std::vector<unsigned int> &
          n_phase_transitions_for_each_composition () const;

          static
          void
          declare_parameters (ParameterHandler &prm);

          void
          parse_parameters (ParameterHandler &prm);


        private:
          std::vector<double> transition_depths;
          std::vector<double> transition_pressures;
          std::vector<double> transition_temperatures;
          std::vector<double> transition_widths;
          std::vector<double> transition_pressure_widths;
          std::vector<double> transition_slopes;

          bool use_depth_instead_of_pressure;

          std::unique_ptr<std::vector<unsigned int>> n_phase_transitions_per_composition;
      };
    }
  }
}


#endif