www.mooseframework.org
Axisymmetric2D3DSolutionFunction.C
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://www.mooseframework.org
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 "MooseError.h"
12 #include "SolutionUserObject.h"
13 
15 
16 template <>
19 {
20  // Get the Function input parameters
22 
23  // Add parameters specific to this object
24  params.addRequiredParam<UserObjectName>("solution",
25  "The SolutionUserObject to extract data from.");
26  params.addParam<std::vector<std::string>>(
27  "from_variables",
28  "The names of the variables in the file that are to be extracted, in x, y "
29  "order if they are vector components");
30 
31  params.addParam<Real>(
32  "scale_factor",
33  1.0,
34  "Scale factor (a) to be applied to the solution (x): ax+b, where b is the 'add_factor'");
35  params.addParam<Real>(
36  "add_factor",
37  0.0,
38  "Add this value (b) to the solution (x): ax+b, where a is the 'scale_factor'");
39  params.addParam<Real>("axial_dimension_ratio",
40  1.0,
41  "Ratio of the axial dimension in the 3d model to that in the 2d model. "
42  "Optinally permits the 3d model to be larger than the 2d model in that "
43  "dimension, and scales vector solutions in that direction by this factor.");
44 
45  params.addParam<RealVectorValue>("2d_axis_point1",
46  RealVectorValue(0, 0, 0),
47  "Start point for axis of symmetry for the 2d model");
48  params.addParam<RealVectorValue>("2d_axis_point2",
49  RealVectorValue(0, 1, 0),
50  "End point for axis of symmetry for the 2d model");
51  params.addParam<RealVectorValue>("3d_axis_point1",
52  RealVectorValue(0, 0, 0),
53  "Start point for axis of symmetry for the 3d model");
54  params.addParam<RealVectorValue>("3d_axis_point2",
55  RealVectorValue(0, 1, 0),
56  "End point for axis of symmetry for the 3d model");
57 
58  params.addParam<unsigned int>("component",
59  "Component of the variable to be computed if it is a vector");
60 
61  params.addClassDescription("Function for reading a 2D axisymmetric solution from file and "
62  "mapping it to a 3D Cartesian model");
63 
64  return params;
65 }
66 
68  const InputParameters & parameters)
69  : Function(parameters),
70  _solution_object_ptr(NULL),
71  _scale_factor(getParam<Real>("scale_factor")),
72  _add_factor(getParam<Real>("add_factor")),
73  _axial_dim_ratio(getParam<Real>("axial_dimension_ratio")),
74  _2d_axis_point1(getParam<RealVectorValue>("2d_axis_point1")),
75  _2d_axis_point2(getParam<RealVectorValue>("2d_axis_point2")),
76  _3d_axis_point1(getParam<RealVectorValue>("3d_axis_point1")),
77  _3d_axis_point2(getParam<RealVectorValue>("3d_axis_point2")),
78  _has_component(isParamValid("component")),
79  _component(_has_component ? getParam<unsigned int>("component") : 99999),
80  _var_names(getParam<std::vector<std::string>>("from_variables"))
81 {
82  if (_has_component && _var_names.size() != 2)
83  mooseError("Must supply names of 2 variables in 'from_variables' if 'component' is specified");
84  else if (!_has_component && _var_names.size() == 2)
85  mooseError("Must supply 'component' if 2 variables specified in 'from_variables'");
86  else if (_var_names.size() > 2)
87  mooseError("If 'from_variables' is specified, it must have either 1 (scalar) or 2 (vector "
88  "components) variables");
89 
90  Point zero;
91  Point unit_vec_y;
92  unit_vec_y(1) = 1;
93  if (_2d_axis_point1 == zero && _2d_axis_point2 == unit_vec_y && _3d_axis_point1 == zero &&
94  _3d_axis_point2 == unit_vec_y)
95  _default_axes = true;
96  else
97  _default_axes = false;
98 
99  if (_3d_axis_point1.relative_fuzzy_equals(_3d_axis_point2))
100  mooseError("3d_axis_point1 and 3d_axis_point2 must be different points");
101  if (_2d_axis_point1.relative_fuzzy_equals(_2d_axis_point2))
102  mooseError("2d_axis_point1 and 2d_axis_point2 must be different points");
103 }
104 
105 void
107 {
108  // Get a pointer to the SolutionUserObject. A pointer is used because the UserObject is not
109  // available during the
110  // construction of the function
111  _solution_object_ptr = &getUserObject<SolutionUserObject>("solution");
112 
113  // If 'from_variable' is not specified, get the value from the SolutionUserObject
114  if (_var_names.size() == 0)
115  {
116  // Get all the variables from the SolutionUserObject
117  const std::vector<std::string> & vars = _solution_object_ptr->variableNames();
118 
119  // If there are more than one, throw an error
120  if (vars.size() > 1)
121  mooseError("If the SolutionUserObject contains multiple variables, the variable name must be "
122  "specified in the input file with 'from_variables'");
123 
124  // Define the variable
125  _var_names.push_back(vars[0]);
126  }
127  if (_2d_axis_point1(2) != 0)
128  mooseError("3rd component of 2d_axis_point1 must be zero");
129  if (_2d_axis_point2(2) != 0)
130  mooseError("3rd component of 2d_axis_point2 must be zero");
131 
133  for (unsigned int i = 0; i < _var_names.size(); ++i)
135 }
136 
137 Real
139 {
140  Point xypoint;
141  Point r_dir_2d;
142  Point z_dir_2d;
143  Point r_dir_3d;
144  Point z_dir_3d;
145  bool r_gt_zero = false;
146 
147  if (_default_axes)
148  {
149  r_dir_2d(0) = 1;
150  z_dir_2d(1) = 1;
151  r_dir_3d = p;
152  r_dir_3d(1) = 0;
153  Real r = r_dir_3d.norm();
155  {
156  r_gt_zero = true;
157  r_dir_3d /= r;
158  }
159  z_dir_3d(1) = 1;
160  xypoint(0) = std::sqrt(p(0) * p(0) + p(2) * p(2));
161  xypoint(1) = p(1) / _axial_dim_ratio;
162  }
163  else
164  {
165  // Find the r, z coordinates of the point in the 3D model relative to the 3D axis
166  z_dir_3d = _3d_axis_point2 - _3d_axis_point1;
167  z_dir_3d /= z_dir_3d.norm();
168  Point v3dp1p(p - _3d_axis_point1);
169  Real z = z_dir_3d * v3dp1p;
170  Point axis_proj = _3d_axis_point1 + z * z_dir_3d; // projection of point onto axis
171  Point axis_proj_to_p = p - axis_proj;
172  Real r = axis_proj_to_p.norm();
174  {
175  r_gt_zero = true;
176  r_dir_3d = axis_proj_to_p / r;
177  }
178 
179  // Convert point in r, z coordinates into x, y coordinates
180  z_dir_2d = _2d_axis_point2 - _2d_axis_point1;
181  z_dir_2d /= z_dir_2d.norm();
182  Point out_of_plane_vec(0, 0, 1);
183  r_dir_2d = z_dir_2d.cross(out_of_plane_vec);
184  r_dir_2d /= r_dir_2d.norm(); // size should be 1, maybe this isn't necessary
185  xypoint = _2d_axis_point1 + z / _axial_dim_ratio * z_dir_2d + r * r_dir_2d;
186  }
187 
188  Real val;
189  if (_has_component)
190  {
191  Real val_x = _solution_object_ptr->pointValue(t, xypoint, _solution_object_var_indices[0]);
192  Real val_y = _solution_object_ptr->pointValue(t, xypoint, _solution_object_var_indices[1]);
193 
194  // val_vec_rz contains the value vector converted from x,y to r,z coordinates
195  Point val_vec_rz;
196  val_vec_rz(0) = r_dir_2d(0) * val_x + r_dir_2d(1) * val_y;
197  val_vec_rz(1) = z_dir_2d(0) * val_x + z_dir_2d(1) * val_y;
198  if (!r_gt_zero && !MooseUtils::absoluteFuzzyEqual(val_vec_rz(0), 0.0))
199  mooseError("In Axisymmetric2D3DSolutionFunction r=0 and r component of value vector != 0");
200  Point val_vec_3d = val_vec_rz(0) * r_dir_3d + val_vec_rz(1) * z_dir_3d;
201 
202  val = val_vec_3d(_component);
203  }
204  else
206 
207  return _scale_factor * val + _add_factor;
208 }
const Real _add_factor
Factor to add to the solution (default = 0)
Base class for function objects.
Definition: Function.h:40
const std::vector< std::string > & variableNames() const
Real pointValue(Real t, const Point &p, const unsigned int local_var_index) const
Returns a value at a specific location and variable (see SolutionFunction)
bool absoluteFuzzyEqual(const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
Function to check whether two variables are equal within an absolute tolerance.
Definition: MooseUtils.h:231
VectorValue< Real > RealVectorValue
Definition: Assembly.h:31
std::vector< unsigned int > _solution_object_var_indices
The local SolutionUserObject indices for the variables extracted from the file.
unsigned int getLocalVarIndex(const std::string &var_name) const
Returns the local index for a given variable name.
Axisymmetric2D3DSolutionFunction(const InputParameters &parameters)
Constructor.
const unsigned int _component
The index of the component.
const RealVectorValue _2d_axis_point1
Two points that define the axis of rotation for the 2d model.
virtual Real value(Real t, const Point &p) override
Override this to evaluate the scalar function at point (t,x,y,z), by default this returns zero...
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
void mooseError(Args &&... args) const
Definition: MooseObject.h:147
const RealVectorValue _3d_axis_point1
Two points that define the axis of rotation for the 3d model.
void addRequiredParam(const std::string &name, const std::string &doc_string)
This method adds a parameter and documentation string to the InputParameters object that will be extr...
InputParameters validParams< Axisymmetric2D3DSolutionFunction >()
bool _default_axes
Are the default axes of rotation being used?
std::vector< std::string > _var_names
The variable names to extract from the file.
Function for reading a 2D axisymmetric solution from file and mapping it to a 3D Cartesian system...
const SolutionUserObject * _solution_object_ptr
Pointer to SolutionUserObject containing the solution of interest.
const Real _axial_dim_ratio
Ratio of axial dimension of 3d model to its counterpart in the 2d model.
virtual void initialSetup() override
Setup the function for use Gathers a pointer to the SolutionUserObject containing the solution that w...
void addClassDescription(const std::string &doc_string)
This method adds a description of the class that will be displayed in the input file syntax dump...
void addParam(const std::string &name, const S &value, const std::string &doc_string)
These methods add an option parameter and a documentation string to the InputParameters object...
InputParameters validParams< Function >()
Definition: Function.C:14
const bool _has_component
If the solution field is a vector, the desired component must be specified Has the component been spe...
registerMooseObject("MooseApp", Axisymmetric2D3DSolutionFunction)
const Real _scale_factor
Factor to scale the solution by (default = 1)
bool absoluteFuzzyGreaterThan(const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
Function to check whether a variable is greater than another variable within an absolute tolerance...
Definition: MooseUtils.h:277