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         733 : MultiSmoothCircleIC::validParams()
      20             : {
      21         733 :   InputParameters params = SmoothCircleBaseIC::validParams();
      22         733 :   params.addClassDescription("Random distribution of smooth circles with given minimum spacing");
      23        1466 :   params.addRequiredParam<unsigned int>("numbub", "The number of bubbles to place");
      24        1466 :   params.addRequiredParam<Real>("bubspac",
      25             :                                 "minimum spacing of bubbles, measured from center to center");
      26        1466 :   params.addParam<unsigned int>("numtries", 1000, "The number of tries");
      27        1466 :   params.addRequiredParam<Real>("radius", "Mean radius value for the circles");
      28        1466 :   params.addParam<Real>("radius_variation",
      29        1466 :                         0.0,
      30             :                         "Plus or minus fraction of random variation in "
      31             :                         "the bubble radius for uniform, standard "
      32             :                         "deviation for normal");
      33        1466 :   MooseEnum rand_options("uniform normal none", "none");
      34        1466 :   params.addParam<MooseEnum>("radius_variation_type",
      35             :                              rand_options,
      36             :                              "Type of distribution that random circle radii will follow");
      37         733 :   return params;
      38         733 : }
      39             : 
      40         376 : MultiSmoothCircleIC::MultiSmoothCircleIC(const InputParameters & parameters)
      41             :   : SmoothCircleBaseIC(parameters),
      42         376 :     _numbub(getParam<unsigned int>("numbub")),
      43         752 :     _bubspac(getParam<Real>("bubspac")),
      44         752 :     _max_num_tries(getParam<unsigned int>("numtries")),
      45         752 :     _radius(getParam<Real>("radius")),
      46         752 :     _radius_variation(getParam<Real>("radius_variation")),
      47        1504 :     _radius_variation_type(getParam<MooseEnum>("radius_variation_type"))
      48             : {
      49         376 : }
      50             : 
      51             : void
      52         360 : MultiSmoothCircleIC::initialSetup()
      53             : {
      54             :   // Set up domain bounds with mesh tools
      55        1440 :   for (const auto i : make_range(Moose::dim))
      56             :   {
      57        1080 :     _bottom_left(i) = _mesh.getMinInDimension(i);
      58        1080 :     _top_right(i) = _mesh.getMaxInDimension(i);
      59             :   }
      60         360 :   _range = _top_right - _bottom_left;
      61             : 
      62             :   // a variation is provided, but the type is set to 'none'
      63         360 :   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         360 :   SmoothCircleBaseIC::initialSetup();
      68         360 : }
      69             : 
      70             : void
      71         360 : MultiSmoothCircleIC::computeCircleRadii()
      72             : {
      73         360 :   _radii.resize(_numbub);
      74             : 
      75        4585 :   for (unsigned int i = 0; i < _numbub; i++)
      76             :   {
      77             :     // Vary bubble radius
      78        4225 :     switch (_radius_variation_type)
      79             :     {
      80          56 :       case 0: // Uniform distribution
      81          56 :         _radii[i] = _radius * (1.0 + (1.0 - 2.0 * _random.rand(_tid)) * _radius_variation);
      82          56 :         break;
      83          50 :       case 1: // Normal distribution
      84          50 :         _radii[i] = _random.randNormal(_tid, _radius, _radius_variation);
      85          50 :         break;
      86        4119 :       case 2: // No variation
      87        4119 :         _radii[i] = _radius;
      88             :     }
      89             : 
      90        4225 :     _radii[i] = std::max(_radii[i], 0.0);
      91             :   }
      92         360 : }
      93             : 
      94             : void
      95          38 : MultiSmoothCircleIC::computeCircleCenters()
      96             : {
      97          38 :   _centers.resize(_numbub);
      98         809 :   for (unsigned int i = 0; i < _numbub; ++i)
      99             :   {
     100             :     // Vary circle center positions
     101             :     unsigned int num_tries = 0;
     102         902 :     while (num_tries < _max_num_tries)
     103             :     {
     104         902 :       num_tries++;
     105             : 
     106             :       RealTensorValue ran;
     107         902 :       ran(0, 0) = _random.rand(_tid);
     108         902 :       ran(1, 1) = _random.rand(_tid);
     109         902 :       ran(2, 2) = _random.rand(_tid);
     110             : 
     111         902 :       _centers[i] = _bottom_left + ran * _range;
     112             : 
     113       12905 :       for (unsigned int j = 0; j < i; ++j)
     114       12134 :         if (_mesh.minPeriodicDistance(_var, _centers[j], _centers[i]) < _bubspac)
     115         131 :           goto fail;
     116             : 
     117             :       // accept the position of the new center
     118         771 :       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         771 :   }
     131          38 : }