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 "MultiSmoothCircleIC.h"
      11             : 
      12             : // MOOSE includes
      13             : #include "MooseMesh.h"
      14             : #include "MooseVariable.h"
      15             : 
      16             : registerMooseObject("PhaseFieldApp", MultiSmoothCircleIC);
      17             : 
      18             : InputParameters
      19         859 : MultiSmoothCircleIC::validParams()
      20             : {
      21         859 :   InputParameters params = SmoothCircleBaseIC::validParams();
      22         859 :   params.addClassDescription("Random distribution of smooth circles with given minimum spacing");
      23        1718 :   params.addRequiredParam<unsigned int>("numbub", "The number of bubbles to place");
      24        1718 :   params.addRequiredParam<Real>("bubspac",
      25             :                                 "minimum spacing of bubbles, measured from center to center");
      26        1718 :   params.addParam<unsigned int>("numtries", 1000, "The number of tries");
      27        1718 :   params.addRequiredParam<Real>("radius", "Mean radius value for the circles");
      28        1718 :   params.addParam<Real>("radius_variation",
      29        1718 :                         0.0,
      30             :                         "Plus or minus fraction of random variation in "
      31             :                         "the bubble radius for uniform, standard "
      32             :                         "deviation for normal");
      33        1718 :   MooseEnum rand_options("uniform normal none", "none");
      34        1718 :   params.addParam<MooseEnum>("radius_variation_type",
      35             :                              rand_options,
      36             :                              "Type of distribution that random circle radii will follow");
      37         859 :   return params;
      38         859 : }
      39             : 
      40         435 : MultiSmoothCircleIC::MultiSmoothCircleIC(const InputParameters & parameters)
      41             :   : SmoothCircleBaseIC(parameters),
      42         435 :     _numbub(getParam<unsigned int>("numbub")),
      43         870 :     _bubspac(getParam<Real>("bubspac")),
      44         870 :     _max_num_tries(getParam<unsigned int>("numtries")),
      45         870 :     _radius(getParam<Real>("radius")),
      46         870 :     _radius_variation(getParam<Real>("radius_variation")),
      47        1740 :     _radius_variation_type(getParam<MooseEnum>("radius_variation_type"))
      48             : {
      49         435 : }
      50             : 
      51             : void
      52         390 : MultiSmoothCircleIC::initialSetup()
      53             : {
      54             :   // Set up domain bounds with mesh tools
      55        1560 :   for (const auto i : make_range(Moose::dim))
      56             :   {
      57        1170 :     _bottom_left(i) = _mesh.getMinInDimension(i);
      58        1170 :     _top_right(i) = _mesh.getMaxInDimension(i);
      59             :   }
      60         390 :   _range = _top_right - _bottom_left;
      61             : 
      62             :   // a variation is provided, but the type is set to 'none'
      63         390 :   if (_radius_variation > 0.0 && _radius_variation_type == 2)
      64           0 :     mooseError("If radius_variation > 0.0, you must pass in a radius_variation_type in "
      65             :                "MultiSmoothCircleIC");
      66             : 
      67         390 :   SmoothCircleBaseIC::initialSetup();
      68         390 : }
      69             : 
      70             : void
      71         390 : MultiSmoothCircleIC::computeCircleRadii()
      72             : {
      73         390 :   _radii.resize(_numbub);
      74             : 
      75        4811 :   for (unsigned int i = 0; i < _numbub; i++)
      76             :   {
      77             :     // Vary bubble radius
      78        4421 :     switch (_radius_variation_type)
      79             :     {
      80          72 :       case 0: // Uniform distribution
      81          72 :         _radii[i] = _radius * (1.0 + (1.0 - 2.0 * _random.rand(_tid)) * _radius_variation);
      82          72 :         break;
      83          70 :       case 1: // Normal distribution
      84          70 :         _radii[i] = _random.randNormal(_tid, _radius, _radius_variation);
      85          70 :         break;
      86        4279 :       case 2: // No variation
      87        4279 :         _radii[i] = _radius;
      88             :     }
      89             : 
      90        4421 :     _radii[i] = std::max(_radii[i], 0.0);
      91             :   }
      92         390 : }
      93             : 
      94             : void
      95          48 : MultiSmoothCircleIC::computeCircleCenters()
      96             : {
      97          48 :   _centers.resize(_numbub);
      98         995 :   for (unsigned int i = 0; i < _numbub; ++i)
      99             :   {
     100             :     // Vary circle center positions
     101             :     unsigned int num_tries = 0;
     102        1122 :     while (num_tries < _max_num_tries)
     103             :     {
     104        1122 :       num_tries++;
     105             : 
     106             :       RealTensorValue ran;
     107        1122 :       ran(0, 0) = _random.rand(_tid);
     108        1122 :       ran(1, 1) = _random.rand(_tid);
     109        1122 :       ran(2, 2) = _random.rand(_tid);
     110             : 
     111        1122 :       _centers[i] = _bottom_left + ran * _range;
     112             : 
     113       15751 :       for (unsigned int j = 0; j < i; ++j)
     114       14804 :         if (_mesh.minPeriodicDistance(_var.number(), _centers[j], _centers[i]) < _bubspac)
     115         175 :           goto fail;
     116             : 
     117             :       // accept the position of the new center
     118         947 :       goto accept;
     119             : 
     120             :     // retry a new position until tries are exhausted
     121             :     fail:
     122             :       continue;
     123             :     }
     124             : 
     125           0 :     if (num_tries == _max_num_tries)
     126           0 :       mooseError("Too many tries in MultiSmoothCircleIC");
     127             : 
     128           0 :   accept:
     129             :     continue;
     130         947 :   }
     131          48 : }