www.mooseframework.org
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
MultiSmoothSuperellipsoidIC Class Reference

MultismoothSuperellipsoidIC creates multiple SmoothSuperellipsoid (number = numbub) that are randomly positioned around the domain, with a minimum spacing equal to bubspac. More...

#include <MultiSmoothSuperellipsoidIC.h>

Inheritance diagram for MultiSmoothSuperellipsoidIC:
[legend]

Public Member Functions

 MultiSmoothSuperellipsoidIC (const InputParameters &parameters)
 
virtual void initialSetup ()
 
virtual Real value (const Point &p)
 
virtual RealGradient gradient (const Point &p)
 

Protected Member Functions

virtual void computeSuperellipsoidSemiaxes ()
 
virtual void computeSuperellipsoidCenters ()
 
virtual void computeSuperellipsoidExponents ()
 
virtual bool ellipsoidsOverlap (unsigned int i, unsigned int j)
 
virtual bool checkExtremes (unsigned int i, unsigned int j)
 
virtual Real computeSuperellipsoidValue (const Point &p, const Point &center, Real a, Real b, Real c, Real n)
 
virtual Real computeSuperellipsoidInverseValue (const Point &p, const Point &center, Real a, Real b, Real c, Real n)
 
RealGradient computeSuperellipsoidGradient (const Point &p, const Point &center, Real a, Real b, Real c, Real n)
 

Protected Attributes

const unsigned int _max_num_tries
 
unsigned int _gk
 
const MooseEnum _semiaxis_variation_type
 
const bool _prevent_overlap
 
const bool _check_extremes
 
const bool _vary_axes_independently
 
Point _bottom_left
 
Point _top_right
 
Point _range
 
std::vector< unsigned int > _numbub
 
std::vector< Real > _bubspac
 
std::vector< Real > _exponent
 
std::vector< Real > _semiaxis_a
 
std::vector< Real > _semiaxis_b
 
std::vector< Real > _semiaxis_c
 
std::vector< Real > _semiaxis_a_variation
 
std::vector< Real > _semiaxis_b_variation
 
std::vector< Real > _semiaxis_c_variation
 
MooseMesh & _mesh
 
Real _invalue
 
Real _outvalue
 
Real _nestedvalue
 
Real _int_width
 
bool _zero_gradient
 
unsigned int _num_dim
 
std::vector< Point > _centers
 
std::vector< Real > _as
 
std::vector< Real > _bs
 
std::vector< Real > _cs
 
std::vector< Real > _ns
 
MooseRandom _random
 

Detailed Description

MultismoothSuperellipsoidIC creates multiple SmoothSuperellipsoid (number = numbub) that are randomly positioned around the domain, with a minimum spacing equal to bubspac.

Definition at line 26 of file MultiSmoothSuperellipsoidIC.h.

Constructor & Destructor Documentation

◆ MultiSmoothSuperellipsoidIC()

MultiSmoothSuperellipsoidIC::MultiSmoothSuperellipsoidIC ( const InputParameters &  parameters)

Definition at line 81 of file MultiSmoothSuperellipsoidIC.C.

82  : SmoothSuperellipsoidBaseIC(parameters),
83  _max_num_tries(getParam<unsigned int>("max_num_tries")),
84  _semiaxis_variation_type(getParam<MooseEnum>("semiaxis_variation_type")),
85  _prevent_overlap(getParam<bool>("prevent_overlap")),
86  _check_extremes(getParam<bool>("check_extremes")),
87  _vary_axes_independently(getParam<bool>("vary_axes_independently")),
88  _numbub(parameters.get<std::vector<unsigned int>>("numbub")),
89  _bubspac(parameters.get<std::vector<Real>>("bubspac")),
90  _exponent(parameters.get<std::vector<Real>>("exponent")),
91  _semiaxis_a(parameters.get<std::vector<Real>>("semiaxis_a")),
92  _semiaxis_b(parameters.get<std::vector<Real>>("semiaxis_b")),
93  _semiaxis_c(parameters.get<std::vector<Real>>("semiaxis_c")),
94  _semiaxis_a_variation(parameters.get<std::vector<Real>>("semiaxis_a_variation")),
95  _semiaxis_b_variation(parameters.get<std::vector<Real>>("semiaxis_b_variation")),
96  _semiaxis_c_variation(parameters.get<std::vector<Real>>("semiaxis_c_variation"))
97 {
98 }
std::vector< unsigned int > _numbub
SmoothSuperellipsoidBaseIC(const InputParameters &parameters)

Member Function Documentation

◆ checkExtremes()

bool MultiSmoothSuperellipsoidIC::checkExtremes ( unsigned int  i,
unsigned int  j 
)
protectedvirtual

Definition at line 281 of file MultiSmoothSuperellipsoidIC.C.

Referenced by ellipsoidsOverlap().

282 {
283  Point tmp_p;
284  for (unsigned int pc = 0; pc < 6; pc++)
285  {
286  tmp_p = _centers[j];
287  // Find extremes along semiaxis of candidate ellipsoids
288  if (pc == 0)
289  tmp_p(0) -= _as[j];
290  else if (pc == 1)
291  tmp_p(0) += _as[j];
292  else if (pc == 2)
293  tmp_p(1) -= _bs[j];
294  else if (pc == 3)
295  tmp_p(1) += _bs[j];
296  else if (pc == 4)
297  tmp_p(2) -= _cs[j];
298  else
299  tmp_p(2) += _cs[j];
300 
301  const Point dist_vec = _mesh.minPeriodicVector(_var.number(), _centers[i], tmp_p);
302  const Real dist = dist_vec.norm();
303 
304  // Handle this case independently because we cannot calculate polar angles at this point
305  if (MooseUtils::absoluteFuzzyEqual(dist, 0.0))
306  return true;
307 
308  // calculate rmn = r^(-n), replacing sin, cos functions with distances
309  Real rmn = (std::pow(std::abs(dist_vec(0) / dist / _as[i]), _ns[i]) +
310  std::pow(std::abs(dist_vec(1) / dist / _bs[i]), _ns[i]) +
311  std::pow(std::abs(dist_vec(2) / dist / _cs[i]), _ns[i]));
312  Real r = std::pow(rmn, (-1.0 / _ns[i]));
313 
314  if (dist < r)
315  return true;
316  }
317 
318  return false;
319 }
ExpressionBuilder::EBTerm pow(const ExpressionBuilder::EBTerm &left, T exponent)

◆ computeSuperellipsoidCenters()

void MultiSmoothSuperellipsoidIC::computeSuperellipsoidCenters ( )
protectedvirtual

Implements SmoothSuperellipsoidBaseIC.

Definition at line 187 of file MultiSmoothSuperellipsoidIC.C.

188 {
189  unsigned int start = _centers.size();
190  _centers.resize(start + _numbub[_gk]);
191 
192  for (unsigned int i = start; i < _centers.size(); i++)
193  {
194  // Vary circle center positions
195  unsigned int num_tries = 0;
196  while (num_tries < _max_num_tries)
197  {
198  num_tries++;
199 
200  RealTensorValue ran;
201  ran(0, 0) = _random.rand(_tid);
202  ran(1, 1) = _random.rand(_tid);
203  ran(2, 2) = _random.rand(_tid);
204 
205  _centers[i] = _bottom_left + ran * _range;
206 
207  for (unsigned int j = 0; j < i; ++j)
208  if (_mesh.minPeriodicDistance(_var.number(), _centers[i], _centers[j]) < _bubspac[_gk] ||
209  ellipsoidsOverlap(i, j))
210  goto fail;
211 
212  // accept the position of the new center
213  goto accept;
214 
215  // retry a new position until tries are exhausted
216  fail:
217  continue;
218  }
219 
220  if (num_tries == _max_num_tries)
221  mooseError("max_num_tries reached in 'MultiSmoothSuperellipsoidIC'.");
222 
223  accept:
224  continue;
225  }
226 }
std::vector< unsigned int > _numbub
virtual bool ellipsoidsOverlap(unsigned int i, unsigned int j)

◆ computeSuperellipsoidExponents()

void MultiSmoothSuperellipsoidIC::computeSuperellipsoidExponents ( )
protectedvirtual

Implements SmoothSuperellipsoidBaseIC.

Definition at line 229 of file MultiSmoothSuperellipsoidIC.C.

230 {
231  unsigned int start = _ns.size();
232  _ns.resize(start + _numbub[_gk]);
233 
234  for (unsigned int i = start; i < _ns.size(); ++i)
235  _ns[i] = _exponent[_gk];
236 }
std::vector< unsigned int > _numbub

◆ computeSuperellipsoidGradient()

RealGradient SmoothSuperellipsoidBaseIC::computeSuperellipsoidGradient ( const Point &  p,
const Point &  center,
Real  a,
Real  b,
Real  c,
Real  n 
)
protectedinherited

Definition at line 195 of file SmoothSuperellipsoidBaseIC.C.

Referenced by SmoothSuperellipsoidBaseIC::gradient().

197 {
198  Point l_center = center;
199  Point l_p = p;
200  // Compute the distance between the current point and the center
201  Real dist = _mesh.minPeriodicDistance(_var.number(), l_p, l_center);
202 
203  // When dist is 0 we are exactly at the center of the superellipsoid so return 0
204  // Handle this case independently because we cannot calculate polar angles at this point
205  if (dist == 0.0)
206  return 0.0;
207 
208  // Compute the distance r from the center of the superellipsoid to its outside edge
209  // along the vector from the center to the current point
210  // This uses the equation for a superellipse in polar coordinates and substitutes
211  // distances for sin, cos functions
212  Point dist_vec = _mesh.minPeriodicVector(_var.number(), center, p);
213  // First calculate rmn = r^(-n)
214  Real rmn = (std::pow(std::abs(dist_vec(0) / dist / a), n) +
215  std::pow(std::abs(dist_vec(1) / dist / b), n) +
216  std::pow(std::abs(dist_vec(2) / dist / c), n));
217  // Then calculate r from rmn
218  Real r = std::pow(rmn, (-1.0 / n));
219 
220  Real DvalueDr = 0.0;
221 
222  if (dist < r + _int_width / 2.0 && dist > r - _int_width / 2.0) // in interfacial region
223  {
224  Real int_pos = (dist - r + _int_width / 2.0) / _int_width;
225  Real Dint_posDr = 1.0 / _int_width;
226  DvalueDr = Dint_posDr * (_invalue - _outvalue) *
227  (-std::sin(int_pos * libMesh::pi) * libMesh::pi) / 2.0;
228  }
229 
230  return dist_vec * (DvalueDr / dist);
231 }
ExpressionBuilder::EBTerm pow(const ExpressionBuilder::EBTerm &left, T exponent)

◆ computeSuperellipsoidInverseValue()

Real SmoothSuperellipsoidBaseIC::computeSuperellipsoidInverseValue ( const Point &  p,
const Point &  center,
Real  a,
Real  b,
Real  c,
Real  n 
)
protectedvirtualinherited

Definition at line 155 of file SmoothSuperellipsoidBaseIC.C.

Referenced by BimodalInverseSuperellipsoidsIC::value().

157 {
158  Point l_center = center;
159  Point l_p = p;
160  // Compute the distance between the current point and the center
161  Real dist = _mesh.minPeriodicDistance(_var.number(), l_p, l_center);
162 
163  // When dist is 0 we are exactly at the center of the superellipsoid so return _invalue
164  // Handle this case independently because we cannot calculate polar angles at this point
165  if (dist == 0.0)
166  return _nestedvalue;
167 
168  // Compute the distance r from the center of the superellipsoid to its outside edge
169  // along the vector from the center to the current point
170  // This uses the equation for a superellipse in polar coordinates and substitutes
171  // distances for sin, cos functions
172  Point dist_vec = _mesh.minPeriodicVector(_var.number(), center, p);
173 
174  // First calculate rmn = r^(-n), replacing sin, cos functions with distances
175  Real rmn = (std::pow(std::abs(dist_vec(0) / dist / a), n) +
176  std::pow(std::abs(dist_vec(1) / dist / b), n) +
177  std::pow(std::abs(dist_vec(2) / dist / c), n));
178  // Then calculate r from rmn
179  Real r = std::pow(rmn, (-1.0 / n));
180 
181  Real value = _invalue;
182 
183  if (dist <= r - _int_width / 2.0) // Reversing inside and outside values
185  else if (dist < r + _int_width / 2.0) // Smooth interface
186  {
187  Real int_pos = (dist - r + _int_width / 2.0) / _int_width;
188  value = _invalue + (_nestedvalue - _invalue) * (1.0 + std::cos(int_pos * libMesh::pi)) / 2.0;
189  }
190 
191  return value;
192 }
virtual Real value(const Point &p)
ExpressionBuilder::EBTerm pow(const ExpressionBuilder::EBTerm &left, T exponent)

◆ computeSuperellipsoidSemiaxes()

void MultiSmoothSuperellipsoidIC::computeSuperellipsoidSemiaxes ( )
protectedvirtual

Implements SmoothSuperellipsoidBaseIC.

Definition at line 138 of file MultiSmoothSuperellipsoidIC.C.

139 {
140  Real randnum;
141  unsigned int start = _as.size();
142  _as.resize(start + _numbub[_gk]);
143  _bs.resize(start + _numbub[_gk]);
144  _cs.resize(start + _numbub[_gk]);
145 
146  for (unsigned int i = start; i < _as.size(); i++)
147  {
148  switch (_semiaxis_variation_type)
149  {
150  case 0: // Uniform distrubtion
151  randnum = _random.rand(_tid);
152  _as[i] = _semiaxis_a[_gk] * (1.0 + (1.0 - 2.0 * randnum) * _semiaxis_a_variation[_gk]);
153  _bs[i] = _semiaxis_b[_gk] *
154  (1.0 +
155  (1.0 - 2.0 * (_vary_axes_independently ? _random.rand(_tid) : randnum)) *
157  _cs[i] = _semiaxis_c[_gk] *
158  (1.0 +
159  (1.0 - 2.0 * (_vary_axes_independently ? _random.rand(_tid) : randnum)) *
161  break;
162 
163  case 1: // Normal distribution
164  randnum = _random.randNormal(_tid, 0, 1);
165  _as[i] = _semiaxis_a[_gk] + (randnum * _semiaxis_a_variation[_gk]);
166  _bs[i] = _semiaxis_b[_gk] +
167  ((_vary_axes_independently ? _random.randNormal(_tid, 0, 1) : randnum) *
169  _cs[i] = _semiaxis_c[_gk] +
170  ((_vary_axes_independently ? _random.randNormal(_tid, 0, 1) : randnum) *
172  break;
173 
174  case 2: // No variation
175  _as[i] = _semiaxis_a[_gk];
176  _bs[i] = _semiaxis_b[_gk];
177  _cs[i] = _semiaxis_c[_gk];
178  }
179 
180  _as[i] = _as[i] < 0.0 ? 0.0 : _as[i];
181  _bs[i] = _bs[i] < 0.0 ? 0.0 : _bs[i];
182  _cs[i] = _cs[i] < 0.0 ? 0.0 : _cs[i];
183  }
184 }
std::vector< unsigned int > _numbub

◆ computeSuperellipsoidValue()

Real SmoothSuperellipsoidBaseIC::computeSuperellipsoidValue ( const Point &  p,
const Point &  center,
Real  a,
Real  b,
Real  c,
Real  n 
)
protectedvirtualinherited

Definition at line 114 of file SmoothSuperellipsoidBaseIC.C.

Referenced by SmoothSuperellipsoidBaseIC::gradient(), SmoothSuperellipsoidBaseIC::value(), and BimodalInverseSuperellipsoidsIC::value().

116 {
117  Point l_center = center;
118  Point l_p = p;
119  // Compute the distance between the current point and the center
120  Real dist = _mesh.minPeriodicDistance(_var.number(), l_p, l_center);
121 
122  // When dist is 0 we are exactly at the center of the superellipsoid so return _invalue
123  // Handle this case independently because we cannot calculate polar angles at this point
124  if (dist == 0.0)
125  return _invalue;
126 
127  // Compute the distance r from the center of the superellipsoid to its outside edge
128  // along the vector from the center to the current point
129  // This uses the equation for a superellipse in polar coordinates and substitutes
130  // distances for sin, cos functions
131  Point dist_vec = _mesh.minPeriodicVector(_var.number(), center, p);
132 
133  // First calculate rmn = r^(-n), replacing sin, cos functions with distances
134  Real rmn = (std::pow(std::abs(dist_vec(0) / dist / a), n) +
135  std::pow(std::abs(dist_vec(1) / dist / b), n) +
136  std::pow(std::abs(dist_vec(2) / dist / c), n));
137  // Then calculate r from rmn
138  Real r = std::pow(rmn, (-1.0 / n));
139 
140  Real value = _outvalue; // Outside superellipsoid
141 
142  if (dist <= r - _int_width / 2.0) // Inside superellipsoid
143  value = _invalue;
144  else if (dist < r + _int_width / 2.0) // Smooth interface
145  {
146  Real int_pos = (dist - r + _int_width / 2.0) / _int_width;
147  value = _outvalue + (_invalue - _outvalue) * (1.0 + std::cos(int_pos * libMesh::pi)) / 2.0;
148  }
149 
150  return value;
151 }
virtual Real value(const Point &p)
ExpressionBuilder::EBTerm pow(const ExpressionBuilder::EBTerm &left, T exponent)

◆ ellipsoidsOverlap()

bool MultiSmoothSuperellipsoidIC::ellipsoidsOverlap ( unsigned int  i,
unsigned int  j 
)
protectedvirtual

Definition at line 239 of file MultiSmoothSuperellipsoidIC.C.

Referenced by computeSuperellipsoidCenters().

240 {
241  // Check for overlap between centers
242  const Point dist_vec = _mesh.minPeriodicVector(_var.number(), _centers[i], _centers[j]);
243  const Real dist = dist_vec.norm();
244 
245  // Handle this case independently because we cannot calculate polar angles at this point
246  if (MooseUtils::absoluteFuzzyEqual(dist, 0.0))
247  return true;
248 
249  // Compute the distance r from the center of the superellipsoid to its outside edge
250  // along the vector from the center to the current point
251  // This uses the equation for a superellipse in polar coordinates and substitutes
252  // distances for sin, cos functions
253  Real rmn;
254 
255  // calculate rmn = r^(-n), replacing sin, cos functions with distances
256  rmn = (std::pow(std::abs(dist_vec(0) / dist / _as[i]), _ns[i]) +
257  std::pow(std::abs(dist_vec(1) / dist / _bs[i]), _ns[i]) +
258  std::pow(std::abs(dist_vec(2) / dist / _cs[i]), _ns[i]));
259  // calculate r2 from rmn
260  const Real r1 = std::pow(rmn, (-1.0 / _ns[i]));
261 
262  // calculate rmn = r^(-n), replacing sin, cos functions with distances
263  rmn = (std::pow(std::abs(dist_vec(0) / dist / _as[j]), _ns[j]) +
264  std::pow(std::abs(dist_vec(1) / dist / _bs[j]), _ns[j]) +
265  std::pow(std::abs(dist_vec(2) / dist / _cs[j]), _ns[j]));
266  const Real r2 = std::pow(rmn, (-1.0 / _ns[j]));
267 
268  if (dist < r1 + r2)
269  return true;
270 
271  // Check for overlap between extremes of new ellipsoid candidate and the center
272  // of accepted ellisoids if _check_extremes enabled
273  if (_check_extremes)
274  return checkExtremes(i, j) || checkExtremes(j, i);
275 
276  // otherwise no overlap has been detected
277  return false;
278 }
virtual bool checkExtremes(unsigned int i, unsigned int j)
ExpressionBuilder::EBTerm pow(const ExpressionBuilder::EBTerm &left, T exponent)

◆ gradient()

RealGradient SmoothSuperellipsoidBaseIC::gradient ( const Point &  p)
virtualinherited

Definition at line 89 of file SmoothSuperellipsoidBaseIC.C.

90 {
91  if (_zero_gradient)
92  return 0.0;
93 
94  RealGradient gradient = 0.0;
95  Real value = _outvalue;
96  Real val2 = 0.0;
97 
98  for (unsigned int ellip = 0; ellip < _centers.size(); ++ellip)
99  {
101  p, _centers[ellip], _as[ellip], _bs[ellip], _cs[ellip], _ns[ellip]);
102  if ((val2 > value && _invalue > _outvalue) || (val2 < value && _outvalue > _invalue))
103  {
104  value = val2;
106  p, _centers[ellip], _as[ellip], _bs[ellip], _cs[ellip], _ns[ellip]);
107  }
108  }
109 
110  return gradient;
111 }
virtual RealGradient gradient(const Point &p)
virtual Real value(const Point &p)
RealGradient computeSuperellipsoidGradient(const Point &p, const Point &center, Real a, Real b, Real c, Real n)
virtual Real computeSuperellipsoidValue(const Point &p, const Point &center, Real a, Real b, Real c, Real n)

◆ initialSetup()

void MultiSmoothSuperellipsoidIC::initialSetup ( )
virtual

Reimplemented from SmoothSuperellipsoidBaseIC.

Definition at line 101 of file MultiSmoothSuperellipsoidIC.C.

102 {
103  unsigned int nv = _numbub.size();
104 
105  if (nv != _bubspac.size() || nv != _exponent.size() || nv != _semiaxis_a.size() ||
106  nv != _semiaxis_b.size() || nv != _semiaxis_c.size())
107  mooseError("Vectors for numbub, bubspac, exponent, semiaxis_a, semiaxis_b, and semiaxis_c must "
108  "be the same size.");
109 
110  if (_semiaxis_variation_type != 2 &&
111  (nv != _semiaxis_a_variation.size() || nv != _semiaxis_b_variation.size() ||
112  nv != _semiaxis_c_variation.size()))
113  mooseError("Vectors for numbub, semiaxis_a_variation, semiaxis_b_variation, and "
114  "semiaxis_c_variation must be the same size.");
115 
116  if (_semiaxis_variation_type == 2 &&
117  (_semiaxis_a_variation.size() > 0 || _semiaxis_b_variation.size() > 0 ||
118  _semiaxis_c_variation.size() > 0))
119  mooseWarning(
120  "Values were provided for semiaxis_a/b/c_variation but semiaxis_variation_type is set "
121  "to 'none' in 'MultiSmoothSuperellipsoidIC'.");
122 
123  for (_gk = 0; _gk < nv; ++_gk)
124  {
125  // Set up domain bounds with mesh tools
126  for (unsigned int i = 0; i < LIBMESH_DIM; i++)
127  {
128  _bottom_left(i) = _mesh.getMinInDimension(i);
129  _top_right(i) = _mesh.getMaxInDimension(i);
130  }
132 
134  }
135 }
std::vector< unsigned int > _numbub

◆ value()

Real SmoothSuperellipsoidBaseIC::value ( const Point &  p)
virtualinherited

Reimplemented in BimodalInverseSuperellipsoidsIC.

Definition at line 72 of file SmoothSuperellipsoidBaseIC.C.

Referenced by SmoothSuperellipsoidBaseIC::computeSuperellipsoidInverseValue(), SmoothSuperellipsoidBaseIC::computeSuperellipsoidValue(), and SmoothSuperellipsoidBaseIC::gradient().

73 {
74  Real value = _outvalue;
75  Real val2 = 0.0;
76 
77  for (unsigned int ellip = 0; ellip < _centers.size() && value != _invalue; ++ellip)
78  {
80  p, _centers[ellip], _as[ellip], _bs[ellip], _cs[ellip], _ns[ellip]);
81  if ((val2 > value && _invalue > _outvalue) || (val2 < value && _outvalue > _invalue))
82  value = val2;
83  }
84 
85  return value;
86 }
virtual Real value(const Point &p)
virtual Real computeSuperellipsoidValue(const Point &p, const Point &center, Real a, Real b, Real c, Real n)

Member Data Documentation

◆ _as

std::vector<Real> SmoothSuperellipsoidBaseIC::_as
protectedinherited

◆ _bottom_left

Point MultiSmoothSuperellipsoidIC::_bottom_left
protected

Definition at line 49 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidCenters(), and initialSetup().

◆ _bs

std::vector<Real> SmoothSuperellipsoidBaseIC::_bs
protectedinherited

◆ _bubspac

std::vector<Real> MultiSmoothSuperellipsoidIC::_bubspac
protected

Definition at line 54 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidCenters(), and initialSetup().

◆ _centers

std::vector<Point> SmoothSuperellipsoidBaseIC::_centers
protectedinherited

◆ _check_extremes

const bool MultiSmoothSuperellipsoidIC::_check_extremes
protected

Definition at line 46 of file MultiSmoothSuperellipsoidIC.h.

Referenced by ellipsoidsOverlap().

◆ _cs

std::vector<Real> SmoothSuperellipsoidBaseIC::_cs
protectedinherited

◆ _exponent

std::vector<Real> MultiSmoothSuperellipsoidIC::_exponent
protected

Definition at line 55 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidExponents(), and initialSetup().

◆ _gk

unsigned int MultiSmoothSuperellipsoidIC::_gk
protected

◆ _int_width

Real SmoothSuperellipsoidBaseIC::_int_width
protectedinherited

◆ _invalue

Real SmoothSuperellipsoidBaseIC::_invalue
protectedinherited

◆ _max_num_tries

const unsigned int MultiSmoothSuperellipsoidIC::_max_num_tries
protected

Definition at line 41 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidCenters().

◆ _mesh

MooseMesh& SmoothSuperellipsoidBaseIC::_mesh
protectedinherited

◆ _nestedvalue

Real SmoothSuperellipsoidBaseIC::_nestedvalue
protectedinherited

◆ _ns

std::vector<Real> SmoothSuperellipsoidBaseIC::_ns
protectedinherited

◆ _num_dim

unsigned int SmoothSuperellipsoidBaseIC::_num_dim
protectedinherited

Definition at line 59 of file SmoothSuperellipsoidBaseIC.h.

◆ _numbub

std::vector<unsigned int> MultiSmoothSuperellipsoidIC::_numbub
protected

◆ _outvalue

Real SmoothSuperellipsoidBaseIC::_outvalue
protectedinherited

◆ _prevent_overlap

const bool MultiSmoothSuperellipsoidIC::_prevent_overlap
protected

Definition at line 45 of file MultiSmoothSuperellipsoidIC.h.

◆ _random

MooseRandom SmoothSuperellipsoidBaseIC::_random
protectedinherited

◆ _range

Point MultiSmoothSuperellipsoidIC::_range
protected

Definition at line 51 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidCenters(), and initialSetup().

◆ _semiaxis_a

std::vector<Real> MultiSmoothSuperellipsoidIC::_semiaxis_a
protected

Definition at line 56 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes(), and initialSetup().

◆ _semiaxis_a_variation

std::vector<Real> MultiSmoothSuperellipsoidIC::_semiaxis_a_variation
protected

Definition at line 59 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes(), and initialSetup().

◆ _semiaxis_b

std::vector<Real> MultiSmoothSuperellipsoidIC::_semiaxis_b
protected

Definition at line 57 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes(), and initialSetup().

◆ _semiaxis_b_variation

std::vector<Real> MultiSmoothSuperellipsoidIC::_semiaxis_b_variation
protected

Definition at line 60 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes(), and initialSetup().

◆ _semiaxis_c

std::vector<Real> MultiSmoothSuperellipsoidIC::_semiaxis_c
protected

Definition at line 58 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes(), and initialSetup().

◆ _semiaxis_c_variation

std::vector<Real> MultiSmoothSuperellipsoidIC::_semiaxis_c_variation
protected

Definition at line 61 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes(), and initialSetup().

◆ _semiaxis_variation_type

const MooseEnum MultiSmoothSuperellipsoidIC::_semiaxis_variation_type
protected

Definition at line 44 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes(), and initialSetup().

◆ _top_right

Point MultiSmoothSuperellipsoidIC::_top_right
protected

Definition at line 50 of file MultiSmoothSuperellipsoidIC.h.

Referenced by initialSetup().

◆ _vary_axes_independently

const bool MultiSmoothSuperellipsoidIC::_vary_axes_independently
protected

Definition at line 47 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes().

◆ _zero_gradient

bool SmoothSuperellipsoidBaseIC::_zero_gradient
protectedinherited

Definition at line 57 of file SmoothSuperellipsoidBaseIC.h.

Referenced by SmoothSuperellipsoidBaseIC::gradient().


The documentation for this class was generated from the following files: