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 "PolyatomicRecoil.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             : registerMooseObject("MagpieApp", PolyatomicRecoil);
      20             : 
      21             : InputParameters
      22          88 : PolyatomicRecoil::validParams()
      23             : {
      24          88 :   InputParameters params = GeneralUserObject::validParams();
      25          88 :   params += ParkinCoulterInterface::validParams();
      26         176 :   params.addRequiredParam<std::vector<unsigned int>>("Z", "Atomic numbers");
      27         176 :   params.addRequiredParam<std::vector<Real>>("A", "Mass numbers");
      28         176 :   params.addRequiredParam<std::vector<Real>>("number_fraction", "Number fractions");
      29         176 :   MooseEnum nrt_damage_types("TOTAL NET ENERGY NET_DERIVATIVE", "TOTAL");
      30         176 :   params.addParam<MooseEnum>(
      31             :       "damage_type",
      32             :       nrt_damage_types,
      33             :       "NRT damage types TOTAL: total number of atoms that have been dispaced during cascade [nij "
      34             :       "in PK JNM, 101, 1981]\n"
      35             :       "NET: number of atoms displaced and not recaptured [nij in PK JNM, 101, 1981]\n"
      36             :       "ENERGY: energy deposted by recoil of type i and energy E[nu_i in PK JNM, 88, 1980]\n"
      37             :       "NET_DERIVATIVE: derivative of NET w.r.t. the partial number fractions.");
      38         176 :   params.addParam<std::string>("displacement_file_base",
      39             :                                "The output file base for displacement function in csv format.");
      40         176 :   params.addRequiredRangeCheckedParam<Real>(
      41             :       "Emax", "Emax > 0", "Maximum desired energy to which displacement functions are computed");
      42          88 :   params.addClassDescription(
      43             :       "PolyatomicRecoil allows computation of total and net displacement functions,"
      44             :       "damage energy functions, and the derivative of the net displacement functions w.r.t. number "
      45             :       "fractions.");
      46          88 :   params.set<ExecFlagEnum>("execute_on") = EXEC_INITIAL;
      47          88 :   params.suppressParameter<ExecFlagEnum>("execute_on");
      48          88 :   return params;
      49          88 : }
      50             : 
      51          44 : PolyatomicRecoil::PolyatomicRecoil(const InputParameters & parameters)
      52          44 :   : GeneralUserObject(parameters), ParkinCoulterInterface(this)
      53             : {
      54          44 : }
      55             : 
      56             : std::vector<unsigned int>
      57          36 : PolyatomicRecoil::atomicNumbers() const
      58             : {
      59         108 :   return getParam<std::vector<unsigned int>>("Z");
      60             : }
      61             : 
      62             : std::vector<Real>
      63          36 : PolyatomicRecoil::massNumbers() const
      64             : {
      65         108 :   return getParam<std::vector<Real>>("A");
      66             : }
      67             : 
      68             : std::vector<Real>
      69          20 : PolyatomicRecoil::numberFractions() const
      70             : {
      71          60 :   return getParam<std::vector<Real>>("number_fraction");
      72             : }
      73             : 
      74             : void
      75          16 : PolyatomicRecoil::initDamageFunctions()
      76             : {
      77             :   // set the displacement function type
      78          16 :   nrt_type type = TOTAL;
      79          48 :   if (getParam<MooseEnum>("damage_type") == "NET")
      80           4 :     type = NET;
      81          36 :   else if (getParam<MooseEnum>("damage_type") == "ENERGY")
      82           4 :     type = ENERGY;
      83          24 :   else if (getParam<MooseEnum>("damage_type") == "NET_DERIVATIVE")
      84           4 :     type = NET_DERIVATIVE;
      85             : 
      86          16 :   if (type == ENERGY)
      87           8 :     _padf = std::make_unique<PolyatomicDamageEnergyFunction>(polyMat(), type, _Ecap);
      88          12 :   else if (type == NET_DERIVATIVE)
      89             :   {
      90           8 :     _padf = std::make_unique<PolyatomicDisplacementFunction>(polyMat(), NET, _Ecap);
      91           8 :     _padf_derivative = std::make_unique<PolyatomicDisplacementDerivativeFunction>(
      92           8 :         polyMat(), type, dynamic_cast<PolyatomicDisplacementFunction *>(_padf.get()), _Ecap);
      93             :   }
      94             :   else
      95          16 :     _padf = std::make_unique<PolyatomicDisplacementFunction>(polyMat(), type, _Ecap);
      96          16 : }
      97             : 
      98             : void
      99          16 : PolyatomicRecoil::execute()
     100             : {
     101          16 :   computeDamageFunctions();
     102          16 : }
     103             : 
     104             : void
     105          16 : PolyatomicRecoil::finalize()
     106             : {
     107          16 :   std::vector<unsigned int> atomic_numbers = atomicNumbers();
     108          16 :   std::vector<Real> mass_numbers = massNumbers();
     109             : 
     110             :   // displacement functions
     111          32 :   if (isParamValid("displacement_file_base"))
     112             :   {
     113          16 :     std::ofstream displacement_file;
     114          48 :     displacement_file.open(getParam<std::string>("displacement_file_base") + ".csv");
     115             : 
     116             :     PolyatomicDisplacementFunction * displacement_function =
     117          16 :         dynamic_cast<PolyatomicDisplacementFunction *>(_padf.get());
     118             :     PolyatomicDamageEnergyFunction * energy_function =
     119          16 :         dynamic_cast<PolyatomicDamageEnergyFunction *>(_padf.get());
     120             : 
     121          16 :     displacement_file << "energy (eV)";
     122          16 :     if (_padf_derivative)
     123          12 :       for (unsigned int projectile = 0; projectile < _padf_derivative->nSpecies(); ++projectile)
     124          24 :         for (unsigned int target = 0; target < _padf_derivative->nSpecies(); ++target)
     125          48 :           for (unsigned int derivative = 0; derivative < _padf_derivative->nSpecies(); ++derivative)
     126             :           {
     127             :             unsigned int projectile_zaid =
     128          32 :                 1000 * atomic_numbers[projectile] + mass_numbers[projectile];
     129          32 :             unsigned int target_zaid = 1000 * atomic_numbers[target] + mass_numbers[target];
     130             :             unsigned int derivative_zaid =
     131          32 :                 1000 * atomic_numbers[derivative] + mass_numbers[derivative];
     132          96 :             displacement_file << ", d(" << projectile_zaid << "->" << target_zaid << ") / d("
     133          32 :                               << derivative_zaid << ")";
     134             :           }
     135             :     else
     136             :     {
     137          12 :       if (displacement_function)
     138          24 :         for (unsigned int projectile = 0; projectile < _padf->nSpecies(); ++projectile)
     139          48 :           for (unsigned int target = 0; target < _padf->nSpecies(); ++target)
     140             :           {
     141             :             unsigned int projectile_zaid =
     142          32 :                 1000 * atomic_numbers[projectile] + mass_numbers[projectile];
     143          32 :             unsigned int target_zaid = 1000 * atomic_numbers[target] + mass_numbers[target];
     144          64 :             displacement_file << "," << projectile_zaid << "->" << target_zaid;
     145             :           }
     146           4 :       else if (energy_function)
     147          12 :         for (unsigned int projectile = 0; projectile < _padf->nSpecies(); ++projectile)
     148             :         {
     149             :           unsigned int projectile_zaid =
     150           8 :               1000 * atomic_numbers[projectile] + mass_numbers[projectile];
     151           8 :           displacement_file << "," << projectile_zaid;
     152             :         }
     153             :       else
     154           0 :         mooseError("Displacement object does not have right type");
     155             :     }
     156             : 
     157             :     displacement_file << std::endl;
     158             : 
     159          16 :     if (_padf_derivative)
     160         104 :       for (unsigned int n = 0; n < _padf->nEnergySteps(); ++n)
     161             :       {
     162             :         displacement_file << _padf_derivative->energyPoint(n);
     163         300 :         for (unsigned int projectile = 0; projectile < _padf_derivative->nSpecies(); ++projectile)
     164         600 :           for (unsigned int target = 0; target < _padf_derivative->nSpecies(); ++target)
     165        1200 :             for (unsigned int derivative = 0; derivative < _padf_derivative->nSpecies();
     166             :                  ++derivative)
     167         800 :               displacement_file << ","
     168             :                                 << _padf_derivative->linearInterpolation(
     169             :                                        _padf_derivative->energyPoint(n),
     170             :                                        projectile,
     171             :                                        target,
     172         800 :                                        derivative);
     173             :         displacement_file << std::endl;
     174             :       }
     175             :     else
     176             :     {
     177          12 :       if (displacement_function)
     178             :       {
     179         364 :         for (unsigned int n = 0; n < _padf->nEnergySteps(); ++n)
     180             :         {
     181             :           displacement_file << _padf->energyPoint(n);
     182        1068 :           for (unsigned int projectile = 0; projectile < _padf->nSpecies(); ++projectile)
     183        2136 :             for (unsigned int target = 0; target < _padf->nSpecies(); ++target)
     184             :             {
     185             :               Real delta_ij =
     186        2848 :                   getParam<MooseEnum>("damage_type") == "TOTAL" && target == projectile ? 1 : 0;
     187        1424 :               displacement_file << ","
     188        1424 :                                 << delta_ij + displacement_function->linearInterpolation(
     189        1424 :                                                   _padf->energyPoint(n), projectile, target);
     190             :             }
     191             :           displacement_file << std::endl;
     192             :         }
     193             :       }
     194           4 :       else if (energy_function)
     195             :       {
     196         404 :         for (unsigned int n = 0; n < _padf->nEnergySteps(); ++n)
     197             :         {
     198             :           displacement_file << _padf->energyPoint(n);
     199        1200 :           for (unsigned int projectile = 0; projectile < _padf->nSpecies(); ++projectile)
     200         800 :             displacement_file << ","
     201             :                               << energy_function->linearInterpolation(_padf->energyPoint(n),
     202         800 :                                                                       projectile);
     203             :           displacement_file << std::endl;
     204             :         }
     205             :       }
     206             :     }
     207             : 
     208          16 :     displacement_file.close();
     209          16 :   }
     210          16 : }
     211             : 
     212             : #endif