dynamic_core.h

Go to the documentation of this file.

/*
  Copyright (C) 2011 - 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 doc/COPYING.  If not see
  <http://www.gnu.org/licenses/>.
*/



#ifndef _aspect_boundary_temperature_dynamic_core_h
#define _aspect_boundary_temperature_dynamic_core_h

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

#include <tuple>

namespace aspect
{
  namespace BoundaryTemperature
  {

    namespace internal
    {
      struct CoreData
      {
        CoreData ();

        double Qs,Qr,Qg,Qk,Ql;

        double Es,Er,Eg,Ek,El,Eh;

        double Ri,Ti,Xi;

        double Q,H;

        double dt;

        double dR_dt,dT_dt,dX_dt;

        double Q_OES;

        bool is_initialized;
      };

      using SolveTimeStepResult = std::tuple<double, double, double>;
    }


    template <int dim>
    class DynamicCore : public Interface<dim>, public aspect::SimulatorAccess<dim>
    {
      public:
        DynamicCore();

        void
        update() override;

        const internal::CoreData &
        get_core_data() const;

        bool
        is_OES_used() const;

        double
        boundary_temperature (const types::boundary_id boundary_indicator,
                              const Point<dim> &location) const override;

        double
        minimal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;

        double
        maximal_temperature (const std::set<types::boundary_id> &fixed_boundary_ids) const override;

        static
        void
        declare_parameters (ParameterHandler &prm);

        void
        parse_parameters (ParameterHandler &prm) override;

        template <class Archive>
        void
        serialize (Archive &ar, const unsigned int version);

        void
        save (std::map<std::string, std::string> &status_strings) const override;

        void
        load (const std::map<std::string, std::string> &status_strings) override;

      private:

        internal::CoreData core_data;

        double inner_temperature;

        double outer_temperature;

        types::boundary_id inner_boundary_id;
        types::boundary_id outer_boundary_id;

        double init_dT_dt;

        double init_dR_dt;

        double init_dX_dt;

        bool is_first_call;

        double Rc;

        double X_init;

        double Delta;

        double P_CMB;

        double Tm0;

        double Tm1;

        double Tm2;

        double Theta;

        bool composition_dependency;

        bool use_bw11;

        double K0;

        double Alpha;

        double Rho_0;

        double Rho_cen;

        double Lh;

        double Rh;

        double Beta_c;

        double k_c;

        double Cp;

        unsigned int n_radioheating_elements;

        std::vector<double> heating_rate;

        std::vector<double> half_life;

        std::vector<double> initial_concentration;

        double L;
        double D;

        double Mc;

        unsigned int max_steps;

        double dTa;

        std::string name_OES;
        struct str_data_OES
        {
          double t;
          double w;

          template <class Archive>
          void serialize (Archive &ar, const unsigned int)
          {
            ar &t
            & w;
          }
        };
        std::vector<struct str_data_OES> data_OES;
        void read_data_OES();
        double compute_OES(double t) const;

        internal::SolveTimeStepResult solve_time_step() const;

        double compute_dT(const double r) const;

        double compute_Tc(const double r) const;

        double compute_Ts(const double r) const;

        double compute_solidus(const double X, const double pressure) const;

        double compute_initial_Ri(const double T) const;

        double compute_X(const double r) const;

        double compute_mass(const double r) const;

        double fun_Sn(const double B, const double R, const unsigned int n) const;

        double compute_rho(const double r) const;

        double compute_T(const double Tc, const double r) const;

        double compute_pressure(const double r) const;

        double compute_gravity_potential(const double r) const;

        std::pair<double,double>
        compute_specific_heating(const double Tc) const;

        std::pair<double,double>
        compute_radio_heating(const double Tc) const;

        std::pair<double,double>
        compute_gravity_heating(const double Tc, const double r, const double X) const;

        std::pair<double,double>
        compute_adiabatic_heating(const double Tc) const;

        std::pair<double,double>
        compute_latent_heating(const double Tc, const double r) const;

        double
        compute_heat_solution(const double Tc, const double r, const double X) const;

        double compute_radioheating_rate() const;

        void update_core_data();

    };
  }
}


#endif