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 "LatticeSmoothCircleIC.h"
      11             : #include "MooseMesh.h"
      12             : 
      13             : registerMooseObject("PhaseFieldApp", LatticeSmoothCircleIC);
      14             : 
      15             : InputParameters
      16         114 : LatticeSmoothCircleIC::validParams()
      17             : {
      18         114 :   InputParameters params = SmoothCircleBaseIC::validParams();
      19         114 :   params.addClassDescription("Perturbed square lattice of smooth circles");
      20         228 :   params.addDeprecatedParam<Real>("Rnd_variation",
      21             :                                   "Variation from central lattice position",
      22             :                                   "use the new parameter name pos_variation");
      23         228 :   params.addParam<Real>("pos_variation", 0.0, "Variation from central lattice position");
      24         228 :   params.addRequiredParam<std::vector<unsigned int>>(
      25             :       "circles_per_side", "Vector containing the number of bubbles along each side");
      26         228 :   params.addParam<unsigned int>("rand_seed", 2000, "random seed");
      27         228 :   params.addRequiredParam<Real>("radius", "Mean radius value for the circles");
      28         228 :   params.addParam<Real>(
      29         228 :       "radius_variation", 0.0, "Plus or minus fraction of random variation in the bubble radius");
      30         228 :   MooseEnum rand_options("uniform normal none", "none");
      31         228 :   params.addParam<MooseEnum>("radius_variation_type",
      32             :                              rand_options,
      33             :                              "Type of distribution that random circle radii will follow");
      34         228 :   params.addParam<bool>(
      35         228 :       "avoid_bounds", true, "Don't place any bubbles on the simulation cell boundaries");
      36         114 :   return params;
      37         114 : }
      38             : 
      39          60 : LatticeSmoothCircleIC::LatticeSmoothCircleIC(const InputParameters & parameters)
      40             :   : SmoothCircleBaseIC(parameters),
      41         180 :     _lattice_variation(isParamValid("Rnd_variation") ? getParam<Real>("Rnd_variation")
      42         180 :                                                      : getParam<Real>("pos_variation")),
      43         120 :     _circles_per_side(getParam<std::vector<unsigned int>>("circles_per_side")),
      44         120 :     _radius(getParam<Real>("radius")),
      45         120 :     _radius_variation(getParam<Real>("radius_variation")),
      46         120 :     _radius_variation_type(getParam<MooseEnum>("radius_variation_type")),
      47         180 :     _avoid_bounds(getParam<bool>("avoid_bounds"))
      48             : {
      49          60 : }
      50             : 
      51             : void
      52          46 : LatticeSmoothCircleIC::initialSetup()
      53             : {
      54             :   // pad circles per side vector to size 3 (with 0)
      55          46 :   _circles_per_side.resize(3);
      56             : 
      57             :   // Set up domain bounds with mesh tools
      58         184 :   for (const auto i : make_range(Moose::dim))
      59             :   {
      60         138 :     _bottom_left(i) = _mesh.getMinInDimension(i);
      61         138 :     _top_right(i) = _mesh.getMaxInDimension(i);
      62             :   }
      63          46 :   _range = _top_right - _bottom_left;
      64             : 
      65             :   // Error checks
      66          46 :   if (_range(0) != 0.0 && _range(1) != 0.0 && _circles_per_side[1] == 0)
      67           0 :     mooseError("If domain is > 1D, circles_per_side must have more than one value");
      68             : 
      69          46 :   if (_range(2) != 0.0 && _circles_per_side[2] == 0)
      70           0 :     mooseError("If domain is 3D, circles_per_side must have three values");
      71             : 
      72          46 :   if (_range(1) == 0.0 && _range(2) == 0.0)
      73             :   {
      74           0 :     _circles_per_side[1] = 0;
      75           0 :     _circles_per_side[2] = 0;
      76             :   }
      77             : 
      78             :   // Set _numbub
      79          46 :   if (_range(2) == 0.0)
      80             :   {
      81          32 :     _circles_per_side[2] = 0;
      82          32 :     _numbub = _circles_per_side[0] * _circles_per_side[1];
      83             :   }
      84             :   else
      85          14 :     _numbub = _circles_per_side[0] * _circles_per_side[1] * _circles_per_side[2];
      86             : 
      87          46 :   switch (_radius_variation_type)
      88             :   {
      89           0 :     case 2: // No variation
      90           0 :       if (_radius_variation > 0.0)
      91           0 :         mooseError("If radius_variation > 0.0, you must pass in a radius_variation_type in "
      92             :                    "LatticeSmoothCircleIC");
      93             :       break;
      94             :   }
      95          46 :   SmoothCircleBaseIC::initialSetup();
      96          46 : }
      97             : 
      98             : void
      99          46 : LatticeSmoothCircleIC::computeCircleRadii()
     100             : {
     101          46 :   _radii.resize(_numbub);
     102             : 
     103         598 :   for (unsigned int i = 0; i < _numbub; i++)
     104             :   {
     105             :     // Vary bubble radius
     106         552 :     switch (_radius_variation_type)
     107             :     {
     108         363 :       case 0: // Uniform distrubtion
     109         363 :         _radii[i] = _radius * (1.0 + (1.0 - 2.0 * _random.rand(_tid)) * _radius_variation);
     110         363 :         break;
     111         189 :       case 1: // Normal distribution
     112         189 :         _radii[i] = _random.randNormal(_tid, _radius, _radius_variation);
     113         189 :         break;
     114           0 :       case 2: // No variation
     115           0 :         _radii[i] = _radius;
     116             :     }
     117             : 
     118         552 :     if (_radii[i] < 0.0)
     119           0 :       _radii[i] = 0.0;
     120             :   }
     121          46 : }
     122             : 
     123             : void
     124          46 : LatticeSmoothCircleIC::computeCircleCenters()
     125             : {
     126          46 :   _centers.resize(_numbub);
     127             : 
     128          46 :   Real x_sep = _range(0) / _circles_per_side[0];
     129          46 :   Real y_sep = _range(1) / _circles_per_side[1];
     130             : 
     131             :   Real z_sep = 0.0;
     132             :   unsigned int z_num = 1.0;
     133             : 
     134          46 :   if (_range(2) > 0.0)
     135             :   {
     136          14 :     z_sep = _range(2) / _circles_per_side[2];
     137             :     z_num = _circles_per_side[2];
     138             :   }
     139             : 
     140             :   unsigned int cnt = 0;
     141         175 :   for (unsigned int i = 0; i < _circles_per_side[0]; ++i)
     142         429 :     for (unsigned int j = 0; j < _circles_per_side[1]; ++j)
     143         852 :       for (unsigned int k = 0; k < z_num; ++k)
     144             :       {
     145         552 :         Real xx = x_sep / 2.0 + i * x_sep;
     146         552 :         Real yy = y_sep / 2.0 + j * y_sep;
     147         552 :         Real zz = z_sep / 2.0 + k * z_sep;
     148             : 
     149             :         // Vary circle position
     150         552 :         xx = xx + (1.0 - 2.0 * _random.rand(_tid)) * _lattice_variation;
     151         552 :         yy = yy + (1.0 - 2.0 * _random.rand(_tid)) * _lattice_variation;
     152             : 
     153         552 :         if (_range(2) != 0.0)
     154         378 :           zz = zz + (1.0 - 2.0 * _random.rand(_tid)) * _lattice_variation;
     155             : 
     156             :         // Verify not out of bounds
     157         552 :         if (_avoid_bounds && xx < _radii[cnt] + _int_width)
     158             :           xx = _radii[cnt] + _int_width;
     159         552 :         if (_avoid_bounds && xx > _range(0) - (_radii[cnt] + _int_width))
     160             :           xx = _range(0) - (_radii[cnt] + _int_width);
     161         552 :         if (_avoid_bounds && yy < _radii[cnt] + _int_width)
     162             :           yy = _radii[cnt] + _int_width;
     163         552 :         if (_avoid_bounds && yy > _range(1) - (_radii[cnt] + _int_width))
     164             :           yy = _range(1) - (_radii[cnt] + _int_width);
     165         552 :         if (_range(2) != 0.0)
     166             :         {
     167         378 :           if (_avoid_bounds && zz < _radii[cnt] + _int_width)
     168             :             zz = _radii[cnt] + _int_width;
     169         378 :           if (_avoid_bounds && zz > _range(2) - (_radii[cnt] + _int_width))
     170             :             zz = _range(2) - (_radii[cnt] + _int_width);
     171             :         }
     172             : 
     173         552 :         _centers[cnt](0) = xx;
     174         552 :         _centers[cnt](1) = yy;
     175         552 :         _centers[cnt](2) = zz;
     176             : 
     177         552 :         cnt++;
     178             :       }
     179          46 : }