Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "PolynomialFreeEnergy.h"
      11             : 
      12             : registerMooseObject("PhaseFieldApp", PolynomialFreeEnergy);
      13             : 
      14             : InputParameters
      15         470 : PolynomialFreeEnergy::validParams()
      16             : {
      17         470 :   InputParameters params = DerivativeParsedMaterialHelper::validParams();
      18         470 :   params.addClassDescription("Polynomial free energy for single component systems");
      19         940 :   MooseEnum poly_order("4 6 8");
      20         940 :   params.addRequiredParam<MooseEnum>(
      21             :       "polynomial_order", poly_order, "Order of polynomial free energy");
      22         940 :   params.addParam<MaterialPropertyName>(
      23             :       "c_eq_name", "c_eq", "Name of material property storing the equilibrium concentration");
      24         940 :   params.addParam<MaterialPropertyName>(
      25             :       "W_name", "barr_height", "Name of the material property storing the barrier height");
      26         940 :   params.addRequiredCoupledVar("c", "Concentration");
      27         470 :   return params;
      28         470 : }
      29             : 
      30         360 : PolynomialFreeEnergy::PolynomialFreeEnergy(const InputParameters & parameters)
      31             :   : DerivativeParsedMaterialHelper(parameters),
      32         360 :     _c("c"),
      33         360 :     _a("c_eq_name"),
      34         360 :     _W("W_name"),
      35        1440 :     _order(getParam<MooseEnum>("polynomial_order"))
      36             : {
      37         360 :   EBFunction free_energy;
      38             : 
      39             :   // Free energy
      40         360 :   switch (_order)
      41             :   {
      42          72 :     case 0: // 4th order
      43          72 :       free_energy(_c, _W, _a) = pow(2.0, 4.0) * _W * pow(_c - _a, 2) * pow(1 - _c - _a, 2);
      44          72 :       break;
      45          72 :     case 1: // 6th order
      46         144 :       free_energy(_c, _W, _a) = pow(2.0, 6.0) * _W *
      47         144 :                                 (2.0 * pow(_c, 6) - 6.0 * pow(_c, 5) +
      48         360 :                                  (3.0 * _a + 27.0 / 4.0 - 3.0 * _a * _a) * pow(_c, 4) +
      49         360 :                                  (-6.0 * _a - 7.0 / 2.0 + 6.0 * _a * _a) * pow(_c, 3) +
      50         360 :                                  (9.0 / 2.0 * _a - 9.0 / 2.0 * _a * _a + 3.0 / 4.0) * pow(_c, 2) +
      51         216 :                                  (3.0 / 2.0 * _a * _a - 3.0 / 2.0 * _a) * _c);
      52          72 :       break;
      53         216 :     case 2: // 8th order
      54         216 :       free_energy(_c, _W, _a) =
      55         432 :           pow(2.0, 8.0) * _W *
      56         648 :           (3.0 * pow(_c, 8) - 12.0 * pow(_c, 7) + (-4.0 * _a * _a + 4.0 * _a + 20.0) * pow(_c, 6) +
      57        1080 :            (12.0 * _a * _a - 12.0 * _a - 18.0) * pow(_c, 5) +
      58        1080 :            (15.0 * _a + 75.0 / 8.0 - 15.0 * _a * _a) * pow(_c, 4) +
      59        1080 :            (-10.0 * _a - 11.0 / 4.0 + 10.0 * _a * _a) * pow(_c, 3) +
      60        1080 :            (15.0 / 4.0 * _a - 15.0 / 4.0 * _a * _a + 3.0 / 8.0) * pow(_c, 2) +
      61         648 :            (3.0 / 4.0 * _a * _a - 3.0 / 4.0 * _a) * _c);
      62         216 :       break;
      63           0 :     default:
      64           0 :       mooseError("Error in PolynomialFreeEnergy: incorrect polynomial order");
      65             :   }
      66             : 
      67             :   // Parse function
      68         720 :   functionParse(free_energy, {}, {}, {"W_name", "c_eq_name"}, {}, {});
      69         360 : }