grain_size_evolution.h

Go to the documentation of this file.

// ------------------------------------------------------
//
// SPDX-License-Identifier: GPL-2.0-or-later
//
// SPDX-FileCopyrightText: Copyright (C) 2024-2026 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_material_model_reaction_model_grain_size_evolution_h
#define _aspect_material_model_reaction_model_grain_size_evolution_h

#include <aspect/material_model/interface.h>
#include <aspect/simulator_access.h>

namespace aspect
{
  namespace MaterialModel
  {
    namespace ReactionModel
    {
      template <int dim>
      class GrainSizeEvolution : public ::aspect::SimulatorAccess<dim>
      {
        public:
          void initialize_phase_function(std::shared_ptr<MaterialUtilities::PhaseFunction<dim>> &phase_function);

          void
          calculate_reaction_terms (const typename Interface<dim>::MaterialModelInputs  &in,
                                    const std::vector<double>                           &adiabatic_pressure,
                                    const std::vector<unsigned int>                     &phase_indices,
                                    const std::function<double(const double,const double,
                                                               const double,const SymmetricTensor<2,dim> &,const unsigned int,const double, const double)>          &dislocation_viscosity,
                                    const std::function<double(
                                      const double, const double, const double,const double,const double,const unsigned int)> &diffusion_viscosity,
                                    const double                                         min_eta,
                                    const double                                         max_eta,
                                    typename Interface<dim>::MaterialModelOutputs       &out) const;

          void
          create_additional_named_outputs (MaterialModel::MaterialModelOutputs<dim> &out) const;

          void
          fill_additional_outputs (const typename MaterialModel::MaterialModelInputs<dim> &in,
                                   const typename MaterialModel::MaterialModelOutputs<dim> &out,
                                   const std::vector<unsigned int> &phase_indices,
                                   const std::vector<double> &dislocation_viscosities,
                                   std::vector<std::shared_ptr<MaterialModel::AdditionalMaterialOutputs<dim>>> &additional_outputs) const;

          static
          void
          declare_parameters (ParameterHandler &prm);

          void
          parse_parameters (ParameterHandler &prm);

        private:
          std::vector<double> grain_growth_activation_energy;
          std::vector<double> grain_growth_activation_volume;
          std::vector<double> grain_growth_rate_constant;
          std::vector<double> grain_growth_exponent;
          double              minimum_grain_size;
          std::vector<double> reciprocal_required_strain;
          std::vector<double> recrystallized_grain_size;

          std::vector<double> grain_boundary_energy;
          std::vector<double> boundary_area_change_work_fraction;
          std::vector<double> geometric_constant;

          struct Formulation
          {
            enum Kind
            {
              paleowattmeter,
              paleopiezometer,
              pinned_grain_damage
            };

            static
            Kind
            parse(const std::string &input)
            {
              if (input == "paleowattmeter")
                return Formulation::paleowattmeter;
              else if (input == "paleopiezometer")
                return Formulation::paleopiezometer;
              else if (input == "pinned grain damage")
                return Formulation::pinned_grain_damage;
              else
                AssertThrow(false, ExcNotImplemented());

              return Formulation::Kind();
            }
          };

          typename Formulation::Kind grain_size_evolution_formulation;

          double compute_partitioning_fraction (const double temperature) const;

          double grain_size_reduction_work_fraction_exponent;
          double minimum_grain_size_reduction_work_fraction;
          double maximum_grain_size_reduction_work_fraction;
          double temperature_minimum_partitioning_power;
          double temperature_maximum_partitioning_power;

          double phase_distribution;

          double roughness_to_grain_size;

          std::shared_ptr<MaterialUtilities::PhaseFunction<dim>> phase_function;

          unsigned int n_phase_transitions;

          double arkode_initial_step_size;

          double arkode_minimum_step_size;
      };
    }

  }
}

#endif