grain_size_evolution.h

Go to the documentation of this file.

/*
  Copyright (C) 2024 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_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