Line data    Source code

       1             : /**********************************************************************/
       2             : /*                     DO NOT MODIFY THIS HEADER                      */
       3             : /* MAGPIE - Mesoscale Atomistic Glue Program for Integrated Execution */
       4             : /*                                                                    */
       5             : /*            Copyright 2017 Battelle Energy Alliance, LLC            */
       6             : /*                        ALL RIGHTS RESERVED                         */
       7             : /**********************************************************************/
       8             : #ifdef GSL_ENABLED
       9             : 
      10             : #include "ParkinCoulterInterface.h"
      11             : #include "PolyatomicDisplacementFunction.h"
      12             : #include "PolyatomicDamageEnergyFunction.h"
      13             : #include "PolyatomicDisplacementDerivativeFunction.h"
      14             : #include "MooseMesh.h"
      15             : 
      16             : // mytrim includes
      17             : #include <mytrim/element.h>
      18             : 
      19             : InputParameters
      20          96 : ParkinCoulterInterface::validParams()
      21             : {
      22          96 :   InputParameters params = emptyInputParameters();
      23         192 :   params.addRequiredParam<std::vector<Real>>("displacement_thresholds", "Dispacement thresholds");
      24         192 :   params.addParam<std::vector<Real>>("lattice_binding_energies", "Lattice binding energies");
      25         288 :   params.addParam<std::vector<std::vector<Real>>>(
      26             :       "Ecap", {{}}, "Capture energy Ecap_ij of species i being trapped in j site");
      27         192 :   params.addRangeCheckedParam<Real>("uniform_energy_spacing_threshold",
      28             :                                     10,
      29             :                                     "uniform_energy_spacing_threshold >= 0",
      30             :                                     "Threshold below which energy points are spaced uniformly.");
      31         288 :   params.addRangeCheckedParam<Real>("uniform_energy_spacing",
      32         192 :                                     0.25,
      33             :                                     "uniform_energy_spacing > 0",
      34             :                                     "Uniform energy spacing below the threshold");
      35         192 :   params.addRequiredRangeCheckedParam<Real>(
      36             :       "logarithmic_energy_spacing",
      37             :       "logarithmic_energy_spacing > 1",
      38             :       "Spacing of the energy points En in log space energy_spacing = E_{n+1} / En");
      39          96 :   return params;
      40           0 : }
      41             : 
      42          48 : ParkinCoulterInterface::ParkinCoulterInterface(const MooseObject * moose_object)
      43          48 :   : _moose_obj(moose_object),
      44          48 :     _pars(moose_object->parameters()),
      45          48 :     _Ecap(_pars.get<std::vector<std::vector<Real>>>("Ecap"))
      46             : {
      47          48 : }
      48             : 
      49             : std::vector<MyTRIM_NS::Element>
      50          24 : ParkinCoulterInterface::polyMat() const
      51             : {
      52             :   std::vector<MyTRIM_NS::Element> poly_mat;
      53          24 :   const auto atomic_numbers = atomicNumbers();
      54          24 :   const auto mass_numbers = massNumbers();
      55          24 :   const auto N = numberFractions();
      56          24 :   const auto threshold = _pars.get<std::vector<Real>>("displacement_thresholds");
      57             :   std::vector<Real> bind;
      58          48 :   if (_pars.isParamValid("lattice_binding_energies"))
      59           0 :     bind = _pars.get<std::vector<Real>>("lattice_binding_energies");
      60             :   else
      61          24 :     bind.assign(atomic_numbers.size(), 0.0);
      62             : 
      63             :   // perform some checks
      64          24 :   if (atomic_numbers.size() != mass_numbers.size() || atomic_numbers.size() != N.size() ||
      65          48 :       atomic_numbers.size() != threshold.size() || atomic_numbers.size() != bind.size())
      66           0 :     mooseError("Size mismatch for at least one parameter array. Z, A, number_fraction, "
      67             :                "displacement_thresholds and lattice_binding_energies"
      68             :                "must all have the same length.");
      69             : 
      70          72 :   for (unsigned int j = 0; j < atomic_numbers.size(); ++j)
      71             :   {
      72          48 :     MyTRIM_NS::Element element;
      73          48 :     element._Z = atomic_numbers[j];
      74          48 :     element._m = mass_numbers[j];
      75          48 :     element._t = N[j];
      76          48 :     element._Edisp = threshold[j];
      77          48 :     element._Elbind = bind[j];
      78          48 :     poly_mat.push_back(element);
      79             :   }
      80          24 :   return poly_mat;
      81             : }
      82             : 
      83             : void
      84          20 : ParkinCoulterInterface::computeDamageFunctions()
      85             : {
      86             :   // callback for allocating damage functions
      87          20 :   initDamageFunctions();
      88             : 
      89             :   Real energy = _padf->minEnergy();
      90          20 :   Real Emax = maxEnergy();
      91          20 :   Real threshold = _pars.get<Real>("uniform_energy_spacing_threshold");
      92          20 :   Real dE = _pars.get<Real>("uniform_energy_spacing");
      93          20 :   Real logdE = _pars.get<Real>("logarithmic_energy_spacing");
      94             : 
      95             :   for (;;) // while (energy <= Emax)
      96             :   {
      97        1040 :     energy = energy < threshold ? energy + dE : energy * logdE;
      98        1040 :     if (energy > Emax)
      99             :     {
     100          20 :       _padf->advanceDisplacements(Emax);
     101             :       break;
     102             :     }
     103             : 
     104             :     // increment displacements for value of energy
     105        1020 :     _padf->advanceDisplacements(energy);
     106             :   }
     107             : 
     108          20 :   if (_padf_derivative)
     109         100 :     for (unsigned int n = 1; n < _padf->nEnergySteps(); ++n)
     110          96 :       _padf_derivative->advanceDisplacements(_padf->energyPoint(n));
     111          20 : }
     112             : 
     113             : #endif