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 23 of file MultiSmoothSuperellipsoidIC.h.

Constructor & Destructor Documentation

MultiSmoothSuperellipsoidIC::MultiSmoothSuperellipsoidIC ( const InputParameters &  parameters)

Definition at line 77 of file MultiSmoothSuperellipsoidIC.C.

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

Member Function Documentation

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

Definition at line 280 of file MultiSmoothSuperellipsoidIC.C.

Referenced by ellipsoidsOverlap().

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

Implements SmoothSuperellipsoidBaseIC.

Definition at line 186 of file MultiSmoothSuperellipsoidIC.C.

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

Implements SmoothSuperellipsoidBaseIC.

Definition at line 228 of file MultiSmoothSuperellipsoidIC.C.

229 {
230  unsigned int start = _ns.size();
231  _ns.resize(start + _numbub[_gk]);
232 
233  for (unsigned int i = start; i < _ns.size(); ++i)
234  _ns[i] = _exponent[_gk];
235 }
std::vector< unsigned int > _numbub
RealGradient SmoothSuperellipsoidBaseIC::computeSuperellipsoidGradient ( const Point &  p,
const Point &  center,
Real  a,
Real  b,
Real  c,
Real  n 
)
protectedinherited

Definition at line 193 of file SmoothSuperellipsoidBaseIC.C.

Referenced by SmoothSuperellipsoidBaseIC::gradient().

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

Definition at line 153 of file SmoothSuperellipsoidBaseIC.C.

Referenced by BimodalInverseSuperellipsoidsIC::value().

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

Implements SmoothSuperellipsoidBaseIC.

Definition at line 137 of file MultiSmoothSuperellipsoidIC.C.

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

Definition at line 112 of file SmoothSuperellipsoidBaseIC.C.

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

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

Definition at line 238 of file MultiSmoothSuperellipsoidIC.C.

Referenced by computeSuperellipsoidCenters().

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

Definition at line 87 of file SmoothSuperellipsoidBaseIC.C.

88 {
89  if (_zero_gradient)
90  return 0.0;
91 
92  RealGradient gradient = 0.0;
93  Real value = _outvalue;
94  Real val2 = 0.0;
95 
96  for (unsigned int ellip = 0; ellip < _centers.size(); ++ellip)
97  {
99  p, _centers[ellip], _as[ellip], _bs[ellip], _cs[ellip], _ns[ellip]);
100  if ((val2 > value && _invalue > _outvalue) || (val2 < value && _outvalue > _invalue))
101  {
102  value = val2;
104  p, _centers[ellip], _as[ellip], _bs[ellip], _cs[ellip], _ns[ellip]);
105  }
106  }
107 
108  return gradient;
109 }
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)
void MultiSmoothSuperellipsoidIC::initialSetup ( )
virtual

Reimplemented from SmoothSuperellipsoidBaseIC.

Definition at line 97 of file MultiSmoothSuperellipsoidIC.C.

98 {
99  unsigned int nv = _numbub.size();
100 
101  if (nv != _bubspac.size() || nv != _exponent.size() || nv != _semiaxis_a.size() ||
102  nv != _semiaxis_b.size() || nv != _semiaxis_c.size())
103  mooseError("Vectors for numbub, bubspac, exponent, semiaxis_a, semiaxis_b, and semiaxis_c must "
104  "be the same size.");
105 
106  if (_semiaxis_variation_type != 2 &&
107  (nv != _semiaxis_a_variation.size() || nv != _semiaxis_b_variation.size() ||
108  nv != _semiaxis_c_variation.size()))
109  mooseError("Vectors for numbub, semiaxis_a_variation, semiaxis_b_variation, and "
110  "semiaxis_c_variation must be the same size.");
111 
112  for (_gk = 0; _gk < nv; ++_gk)
113  {
114  // Set up domain bounds with mesh tools
115  for (unsigned int i = 0; i < LIBMESH_DIM; i++)
116  {
117  _bottom_left(i) = _mesh.getMinInDimension(i);
118  _top_right(i) = _mesh.getMaxInDimension(i);
119  }
121 
123  mooseError("If Semiaxis_a_variation > 0.0, you must pass in a Semiaxis_variation_type in "
124  "MultiSmoothSuperellipsoidIC");
126  mooseError("If Semiaxis_b_variation > 0.0, you must pass in a Semiaxis_variation_type in "
127  "MultiSmoothSuperellipsoidIC");
129  mooseError("If Semiaxis_c_variation > 0.0, you must pass in a Semiaxis_variation_type in "
130  "MultiSmoothSuperellipsoidIC");
131 
133  }
134 }
std::vector< unsigned int > _numbub
Real SmoothSuperellipsoidBaseIC::value ( const Point &  p)
virtualinherited

Reimplemented in BimodalInverseSuperellipsoidsIC.

Definition at line 70 of file SmoothSuperellipsoidBaseIC.C.

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

71 {
72  Real value = _outvalue;
73  Real val2 = 0.0;
74 
75  for (unsigned int ellip = 0; ellip < _centers.size() && value != _invalue; ++ellip)
76  {
78  p, _centers[ellip], _as[ellip], _bs[ellip], _cs[ellip], _ns[ellip]);
79  if ((val2 > value && _invalue > _outvalue) || (val2 < value && _outvalue > _invalue))
80  value = val2;
81  }
82 
83  return value;
84 }
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

std::vector<Real> SmoothSuperellipsoidBaseIC::_as
protectedinherited
Point MultiSmoothSuperellipsoidIC::_bottom_left
protected

Definition at line 46 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidCenters(), and initialSetup().

std::vector<Real> SmoothSuperellipsoidBaseIC::_bs
protectedinherited
std::vector<Real> MultiSmoothSuperellipsoidIC::_bubspac
protected

Definition at line 51 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidCenters(), and initialSetup().

std::vector<Point> SmoothSuperellipsoidBaseIC::_centers
protectedinherited
const bool MultiSmoothSuperellipsoidIC::_check_extremes
protected

Definition at line 43 of file MultiSmoothSuperellipsoidIC.h.

Referenced by ellipsoidsOverlap().

std::vector<Real> SmoothSuperellipsoidBaseIC::_cs
protectedinherited
std::vector<Real> MultiSmoothSuperellipsoidIC::_exponent
protected

Definition at line 52 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidExponents(), and initialSetup().

unsigned int MultiSmoothSuperellipsoidIC::_gk
protected
Real SmoothSuperellipsoidBaseIC::_int_width
protectedinherited
Real SmoothSuperellipsoidBaseIC::_invalue
protectedinherited
const unsigned int MultiSmoothSuperellipsoidIC::_max_num_tries
protected

Definition at line 38 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidCenters().

MooseMesh& SmoothSuperellipsoidBaseIC::_mesh
protectedinherited
Real SmoothSuperellipsoidBaseIC::_nestedvalue
protectedinherited
std::vector<Real> SmoothSuperellipsoidBaseIC::_ns
protectedinherited
unsigned int SmoothSuperellipsoidBaseIC::_num_dim
protectedinherited

Definition at line 56 of file SmoothSuperellipsoidBaseIC.h.

std::vector<unsigned int> MultiSmoothSuperellipsoidIC::_numbub
protected
Real SmoothSuperellipsoidBaseIC::_outvalue
protectedinherited
const bool MultiSmoothSuperellipsoidIC::_prevent_overlap
protected

Definition at line 42 of file MultiSmoothSuperellipsoidIC.h.

MooseRandom SmoothSuperellipsoidBaseIC::_random
protectedinherited
Point MultiSmoothSuperellipsoidIC::_range
protected

Definition at line 48 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidCenters(), and initialSetup().

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

Definition at line 53 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes(), and initialSetup().

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

Definition at line 56 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes(), and initialSetup().

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

Definition at line 54 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes(), and initialSetup().

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

Definition at line 57 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes(), and initialSetup().

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

Definition at line 55 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes(), and initialSetup().

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

Definition at line 58 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes(), and initialSetup().

const MooseEnum MultiSmoothSuperellipsoidIC::_semiaxis_variation_type
protected

Definition at line 41 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes(), and initialSetup().

Point MultiSmoothSuperellipsoidIC::_top_right
protected

Definition at line 47 of file MultiSmoothSuperellipsoidIC.h.

Referenced by initialSetup().

const bool MultiSmoothSuperellipsoidIC::_vary_axes_independently
protected

Definition at line 44 of file MultiSmoothSuperellipsoidIC.h.

Referenced by computeSuperellipsoidSemiaxes().

bool SmoothSuperellipsoidBaseIC::_zero_gradient
protectedinherited

Definition at line 54 of file SmoothSuperellipsoidBaseIC.h.

Referenced by SmoothSuperellipsoidBaseIC::gradient().


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