interface.h

Go to the documentation of this file.

/*
  Copyright (C) 2011 - 2018 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_interface_h
#define _aspect_material_model_interface_h

#include <aspect/global.h>
#include <aspect/plugins.h>
#include <aspect/material_model/utilities.h>

#include <deal.II/base/point.h>
#include <deal.II/base/quadrature.h>
#include <deal.II/base/symmetric_tensor.h>
#include <deal.II/base/parameter_handler.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/fe/mapping.h>
#include <deal.II/fe/fe_values.h>
#include <deal.II/fe/component_mask.h>
#include <deal.II/numerics/data_postprocessor.h>
#include <deal.II/base/signaling_nan.h>

namespace aspect
{
  template <int dim>
  struct Introspection;


  namespace MaterialModel
  {
    using namespace dealii;

    namespace NonlinearDependence
    {
      enum Dependence
      {
        uninitialized        = 0,

        none                 = 1,
        temperature          = 2,
        pressure             = 4,
        strain_rate          = 8,
        compositional_fields = 16,

        any_variable         = temperature | pressure | strain_rate | compositional_fields
      };


      inline Dependence operator | (const Dependence d1,
                                    const Dependence d2)
      {
        return Dependence(static_cast<int>(d1) | static_cast<int>(d2));
      }

      inline Dependence operator |= (Dependence &d1,
                                     const Dependence d2)
      {
        d1 = (d1 | d2);
        return d1;
      }

      struct ModelDependence
      {
        Dependence viscosity;

        Dependence density;

        Dependence compressibility;

        Dependence specific_heat;

        Dependence thermal_conductivity;

        ModelDependence ();
      };

      bool
      identifies_single_variable(const Dependence dependence);
    }


    template <int dim>     class AdditionalMaterialInputs;


    template <int dim>
    struct MaterialModelInputs
    {
        MaterialModelInputs(const unsigned int n_points,
                            const unsigned int n_comp);

        MaterialModelInputs(const DataPostprocessorInputs::Vector<dim> &input_data,
                            const Introspection<dim> &introspection,
                            const bool use_strain_rate = true);


        MaterialModelInputs(const FEValuesBase<dim,dim> &fe_values,
                            const typename DoFHandler<dim>::active_cell_iterator &cell,
                            const Introspection<dim> &introspection,
                            const LinearAlgebra::BlockVector &solution_vector,
                            const bool use_strain_rates = true);

        MaterialModelInputs(const MaterialModelInputs<dim> &material);

        void reinit(const FEValuesBase<dim,dim> &fe_values,
                    const typename DoFHandler<dim>::active_cell_iterator &cell,
                    const Introspection<dim> &introspection,
                    const LinearAlgebra::BlockVector &solution_vector,
                    const bool use_strain_rates = true);


        std::vector<Point<dim> > position;

        std::vector<double> temperature;

        std::vector<double> pressure;

        std::vector<Tensor<1,dim> > pressure_gradient;

        std::vector<Tensor<1,dim> > velocity;

        std::vector<std::vector<double> > composition;

        std::vector<SymmetricTensor<2,dim> > strain_rate;

        const typename DoFHandler<dim>::active_cell_iterator *cell DEAL_II_DEPRECATED;

        typename DoFHandler<dim>::active_cell_iterator current_cell;

        std::vector<std::shared_ptr<AdditionalMaterialInputs<dim> > > additional_inputs;

        template <class AdditionalInputType>
        AdditionalInputType *get_additional_input();

        template <class AdditionalInputType>
        const AdditionalInputType *get_additional_input() const;

      private:
        MaterialModelInputs &operator=(const MaterialModelInputs &material);
    };


    template <int dim>     class AdditionalMaterialOutputs;


    template <int dim>
    struct MaterialModelOutputs
    {
      MaterialModelOutputs (const unsigned int n_points,
                            const unsigned int n_comp);

      std::vector<double> viscosities;

      std::vector<double> densities;

      std::vector<double> thermal_expansion_coefficients;

      std::vector<double> specific_heat;

      std::vector<double> thermal_conductivities;

      std::vector<double> compressibilities;

      std::vector<double> entropy_derivative_pressure;

      std::vector<double> entropy_derivative_temperature;

      std::vector<std::vector<double> > reaction_terms;

      std::vector<std::shared_ptr<AdditionalMaterialOutputs<dim> > > additional_outputs;

      template <class AdditionalOutputType>
      AdditionalOutputType *get_additional_output();

      template <class AdditionalOutputType>
      const AdditionalOutputType *get_additional_output() const;
    };


    namespace MaterialAveraging
    {
      enum AveragingOperation
      {
        none,
        arithmetic_average,
        harmonic_average,
        geometric_average,
        pick_largest,
        project_to_Q1,
        log_average
      };


      std::string get_averaging_operation_names ();

      AveragingOperation parse_averaging_operation_name (const std::string &s);

      template <int dim>
      void average (const AveragingOperation operation,
                    const typename DoFHandler<dim>::active_cell_iterator &cell,
                    const Quadrature<dim>         &quadrature_formula,
                    const Mapping<dim>            &mapping,
                    MaterialModelOutputs<dim>     &values_out);

      void average_property (const AveragingOperation  operation,
                             const FullMatrix<double>      &projection_matrix,
                             const FullMatrix<double>      &expansion_matrix,
                             std::vector<double>           &values_out);
    }


    template <int dim>
    class AdditionalMaterialInputs
    {
      public:
        virtual ~AdditionalMaterialInputs()
        {}

        virtual void
        fill (const LinearAlgebra::BlockVector &solution,
              const FEValuesBase<dim>          &fe_values,
              const Introspection<dim>         &introspection) = 0;
    };


    template <int dim>
    class AdditionalMaterialOutputs
    {
      public:
        virtual ~AdditionalMaterialOutputs()
        {}

        virtual void average (const MaterialAveraging::AveragingOperation /*operation*/,
                              const FullMatrix<double>  &/*projection_matrix*/,
                              const FullMatrix<double>  &/*expansion_matrix*/)
        {}
    };


    template <int dim>
    class NamedAdditionalMaterialOutputs : public AdditionalMaterialOutputs<dim>
    {
      public:
        NamedAdditionalMaterialOutputs(const std::vector<std::string> &output_names);

        virtual ~NamedAdditionalMaterialOutputs();

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

        virtual std::vector<double> get_nth_output(const unsigned int idx) const = 0;

        virtual void average (const MaterialAveraging::AveragingOperation /*operation*/,
                              const FullMatrix<double>  &/*projection_matrix*/,
                              const FullMatrix<double>  &/*expansion_matrix*/)
        {}

      private:
        const std::vector<std::string> names;
    };


    template <int dim>
    class SeismicAdditionalOutputs : public NamedAdditionalMaterialOutputs<dim>
    {
      public:
        SeismicAdditionalOutputs(const unsigned int n_points);

        virtual std::vector<double> get_nth_output(const unsigned int idx) const;

        std::vector<double> vs;

        std::vector<double> vp;
    };


    template <int dim>
    class ReactionRateOutputs : public NamedAdditionalMaterialOutputs<dim>
    {
      public:
        ReactionRateOutputs (const unsigned int n_points,
                             const unsigned int n_comp);

        virtual std::vector<double> get_nth_output(const unsigned int idx) const;

        std::vector<std::vector<double> > reaction_rates;
    };


    template <int dim>
    class PrescribedFieldOutputs : public NamedAdditionalMaterialOutputs<dim>
    {
      public:
        PrescribedFieldOutputs (const unsigned int n_points,
                                const unsigned int n_comp);

        virtual std::vector<double> get_nth_output(const unsigned int idx) const;

        std::vector<std::vector<double> > prescribed_field_outputs;
    };


    template <int dim>
    class AdditionalMaterialOutputsStokesRHS: public AdditionalMaterialOutputs<dim>
    {
      public:
        AdditionalMaterialOutputsStokesRHS(const unsigned int n_points)
          : rhs_u(n_points), rhs_p(n_points), rhs_melt_pc(n_points)
        {}

        virtual ~AdditionalMaterialOutputsStokesRHS()
        {}

        virtual void average (const MaterialAveraging::AveragingOperation /*operation*/,
                              const FullMatrix<double>  &/*projection_matrix*/,
                              const FullMatrix<double>  &/*expansion_matrix*/)
        {
          // TODO: not implemented
        }

        std::vector<Tensor<1,dim> > rhs_u;

        std::vector<double> rhs_p;

        std::vector<double> rhs_melt_pc;
    };

    template <int dim>
    class ElasticOutputs: public AdditionalMaterialOutputs<dim>
    {
      public:
        ElasticOutputs(const unsigned int n_points)
          : elastic_force(n_points, numbers::signaling_nan<Tensor<2,dim> >() )
        {}

        virtual ~ElasticOutputs()
        {}

        virtual void average (const MaterialAveraging::AveragingOperation operation,
                              const FullMatrix<double>  &/*projection_matrix*/,
                              const FullMatrix<double>  &/*expansion_matrix*/)
        {
          AssertThrow(operation == MaterialAveraging::AveragingOperation::none,ExcNotImplemented());
          return;
        }

        std::vector<Tensor<2,dim> > elastic_force;
    };



    template <int dim>
    class Interface
    {
      public:
        typedef MaterialModel::MaterialModelInputs<dim> MaterialModelInputs;
        typedef MaterialModel::MaterialModelOutputs<dim> MaterialModelOutputs;

        virtual ~Interface();

        virtual
        void
        initialize ();

        virtual void update ();

        const NonlinearDependence::ModelDependence &
        get_model_dependence () const;

        virtual bool is_compressible () const = 0;
        virtual double reference_viscosity () const = 0;
        virtual
        void evaluate (const MaterialModel::MaterialModelInputs<dim> &in,
                       MaterialModel::MaterialModelOutputs<dim> &out) const = 0;
        static
        void
        declare_parameters (ParameterHandler &prm);

        virtual
        void
        parse_parameters (ParameterHandler &prm);
        virtual
        void
        create_additional_named_outputs (MaterialModelOutputs &outputs) const;


        virtual
        void
        fill_additional_material_model_inputs(MaterialModel::MaterialModelInputs<dim> &input,
                                              const LinearAlgebra::BlockVector        &solution,
                                              const FEValuesBase<dim>                 &fe_values,
                                              const Introspection<dim>                &introspection) const;

      protected:
        NonlinearDependence::ModelDependence model_dependence;
    };

    template <int dim>
    void
    register_material_model (const std::string &name,
                             const std::string &description,
                             void (*declare_parameters_function) (ParameterHandler &),
                             Interface<dim> *(*factory_function) ());

    template <int dim>
    Interface<dim> *
    create_material_model (const std::string &model_name);


    template <int dim>
    Interface<dim> *
    create_material_model (ParameterHandler &prm);


    template <int dim>
    std::string
    get_valid_model_names_pattern ();


    template <int dim>
    void
    declare_parameters (ParameterHandler &prm);



    template <int dim>
    void
    write_plugin_graph (std::ostream &output_stream);



// --------------------- template function definitions ----------------------------------

    template <int dim>
    template <class AdditionalInputType>
    AdditionalInputType *MaterialModelInputs<dim>::get_additional_input()
    {
      for (unsigned int i=0; i<additional_inputs.size(); ++i)
        {
          AdditionalInputType *result = dynamic_cast<AdditionalInputType *> (additional_inputs[i].get());
          if (result)
            return result;
        }
      return nullptr;
    }


    template <int dim>
    template <class AdditionalInputType>
    const AdditionalInputType *MaterialModelInputs<dim>::get_additional_input() const
    {
      for (unsigned int i=0; i<additional_inputs.size(); ++i)
        {
          const AdditionalInputType *result = dynamic_cast<const AdditionalInputType *> (additional_inputs[i].get());
          if (result)
            return result;
        }
      return nullptr;
    }


    template <int dim>
    template <class AdditionalOutputType>
    AdditionalOutputType *MaterialModelOutputs<dim>::get_additional_output()
    {
      for (unsigned int i=0; i<additional_outputs.size(); ++i)
        {
          AdditionalOutputType *result = dynamic_cast<AdditionalOutputType *> (additional_outputs[i].get());
          if (result)
            return result;
        }
      return nullptr;
    }


    template <int dim>
    template <class AdditionalOutputType>
    const AdditionalOutputType *MaterialModelOutputs<dim>::get_additional_output() const
    {
      for (unsigned int i=0; i<additional_outputs.size(); ++i)
        {
          const AdditionalOutputType *result = dynamic_cast<const AdditionalOutputType *> (additional_outputs[i].get());
          if (result)
            return result;
        }
      return nullptr;
    }


#define ASPECT_REGISTER_MATERIAL_MODEL(classname,name,description) \
  template class classname<2>; \
  template class classname<3>; \
  namespace ASPECT_REGISTER_MATERIAL_MODEL_ ## classname \
  { \
    aspect::internal::Plugins::RegisterHelper<aspect::MaterialModel::Interface<2>,classname<2> > \
    dummy_ ## classname ## _2d (&aspect::MaterialModel::register_material_model<2>, \
                                name, description); \
    aspect::internal::Plugins::RegisterHelper<aspect::MaterialModel::Interface<3>,classname<3> > \
    dummy_ ## classname ## _3d (&aspect::MaterialModel::register_material_model<3>, \
                                name, description); \
  }
  }
}


#endif