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 
18 {
19  // Get the Function input parameters
21 
22  // Add parameters specific to this object
23  params.addRequiredParam<UserObjectName>("solution",
24  "The SolutionUserObject to extract data from.");
25  params.addParam<std::vector<std::string>>(
26  "from_variables",
27  "The names of the variables in the file that are to be extracted, in x, y "
28  "order if they are vector components");
29 
30  params.addParam<Real>(
31  "scale_factor",
32  1.0,
33  "Scale factor (a) to be applied to the solution (x): ax+b, where b is the 'add_factor'");
34  params.addParam<Real>(
35  "add_factor",
36  0.0,
37  "Add this value (b) to the solution (x): ax+b, where a is the 'scale_factor'");
38  params.addParam<Real>("axial_dimension_ratio",
39  1.0,
40  "Ratio of the axial dimension in the 3d model to that in the 2d model. "
41  "Optionally permits the 3d model to be larger than the 2d model in that "
42  "dimension, and scales vector solutions in that direction by this factor.");
43 
44  params.addParam<RealVectorValue>("2d_axis_point1",
45  RealVectorValue(0, 0, 0),
46  "Start point for axis of symmetry for the 2d model");
47  params.addParam<RealVectorValue>("2d_axis_point2",
48  RealVectorValue(0, 1, 0),
49  "End point for axis of symmetry for the 2d model");
50  params.addParam<RealVectorValue>("3d_axis_point1",
51  RealVectorValue(0, 0, 0),
52  "Start point for axis of symmetry for the 3d model");
53  params.addParam<RealVectorValue>("3d_axis_point2",
54  RealVectorValue(0, 1, 0),
55  "End point for axis of symmetry for the 3d model");
56 
57  params.addParam<unsigned int>("component",
58  "Component of the variable to be computed if it is a vector");
59 
60  params.addClassDescription("Function for reading a 2D axisymmetric solution from file and "
61  "mapping it to a 3D Cartesian model");
62 
63  return params;
64 }
65 
67  const InputParameters & parameters)
68  : Function(parameters),
69  _solution_object_ptr(NULL),
70  _scale_factor(getParam<Real>("scale_factor")),
71  _add_factor(getParam<Real>("add_factor")),
72  _axial_dim_ratio(getParam<Real>("axial_dimension_ratio")),
73  _2d_axis_point1(getParam<RealVectorValue>("2d_axis_point1")),
74  _2d_axis_point2(getParam<RealVectorValue>("2d_axis_point2")),
75  _3d_axis_point1(getParam<RealVectorValue>("3d_axis_point1")),
76  _3d_axis_point2(getParam<RealVectorValue>("3d_axis_point2")),
77  _has_component(isParamValid("component")),
78  _component(_has_component ? getParam<unsigned int>("component") : 99999),
79  _var_names(getParam<std::vector<std::string>>("from_variables"))
80 {
81  if (_has_component && _var_names.size() != 2)
82  mooseError("Must supply names of 2 variables in 'from_variables' if 'component' is specified");
83  else if (!_has_component && _var_names.size() == 2)
84  mooseError("Must supply 'component' if 2 variables specified in 'from_variables'");
85  else if (_var_names.size() > 2)
86  mooseError("If 'from_variables' is specified, it must have either 1 (scalar) or 2 (vector "
87  "components) variables");
88 
89  Point zero;
90  Point unit_vec_y;
91  unit_vec_y(1) = 1;
92  if (_2d_axis_point1 == zero && _2d_axis_point2 == unit_vec_y && _3d_axis_point1 == zero &&
93  _3d_axis_point2 == unit_vec_y)
94  _default_axes = true;
95  else
96  _default_axes = false;
97 
99  mooseError("3d_axis_point1 and 3d_axis_point2 must be different points");
101  mooseError("2d_axis_point1 and 2d_axis_point2 must be different points");
102 }
103 
104 void
106 {
107  // Get a pointer to the SolutionUserObject. A pointer is used because the UserObject is not
108  // available during the
109  // construction of the function
110  _solution_object_ptr = &getUserObject<SolutionUserObject>("solution");
111 
112  // If 'from_variable' is not specified, get the value from the SolutionUserObject
113  if (_var_names.size() == 0)
114  {
115  // Get all the variables from the SolutionUserObject
116  const std::vector<std::string> & vars = _solution_object_ptr->variableNames();
117 
118  // If there are more than one, throw an error
119  if (vars.size() > 1)
120  mooseError("If the SolutionUserObject contains multiple variables, the variable name must be "
121  "specified in the input file with 'from_variables'");
122 
123  // Define the variable
124  _var_names.push_back(vars[0]);
125  }
126  if (_2d_axis_point1(2) != 0)
127  mooseError("3rd component of 2d_axis_point1 must be zero");
128  if (_2d_axis_point2(2) != 0)
129  mooseError("3rd component of 2d_axis_point2 must be zero");
130 
132  for (unsigned int i = 0; i < _var_names.size(); ++i)
134 }
135 
136 Real
137 Axisymmetric2D3DSolutionFunction::value(Real t, const Point & p) const
138 {
139  Point xypoint;
140  Point r_dir_2d;
141  Point z_dir_2d;
142  Point r_dir_3d;
143  Point z_dir_3d;
144  bool r_gt_zero = false;
145 
146  if (_default_axes)
147  {
148  r_dir_2d(0) = 1;
149  z_dir_2d(1) = 1;
150  r_dir_3d = p;
151  r_dir_3d(1) = 0;
152  Real r = r_dir_3d.norm();
154  {
155  r_gt_zero = true;
156  r_dir_3d /= r;
157  }
158  z_dir_3d(1) = 1;
159  xypoint(0) = std::sqrt(p(0) * p(0) + p(2) * p(2));
160  xypoint(1) = p(1) / _axial_dim_ratio;
161  }
162  else
163  {
164  // Find the r, z coordinates of the point in the 3D model relative to the 3D axis
165  z_dir_3d = _3d_axis_point2 - _3d_axis_point1;
166  z_dir_3d /= z_dir_3d.norm();
167  Point v3dp1p(p - _3d_axis_point1);
168  Real z = z_dir_3d * v3dp1p;
169  Point axis_proj = _3d_axis_point1 + z * z_dir_3d; // projection of point onto axis
170  Point axis_proj_to_p = p - axis_proj;
171  Real r = axis_proj_to_p.norm();
173  {
174  r_gt_zero = true;
175  r_dir_3d = axis_proj_to_p / r;
176  }
177 
178  // Convert point in r, z coordinates into x, y coordinates
179  z_dir_2d = _2d_axis_point2 - _2d_axis_point1;
180  z_dir_2d /= z_dir_2d.norm();
181  Point out_of_plane_vec(0, 0, 1);
182  r_dir_2d = z_dir_2d.cross(out_of_plane_vec);
183  r_dir_2d /= r_dir_2d.norm(); // size should be 1, maybe this isn't necessary
184  xypoint = _2d_axis_point1 + z / _axial_dim_ratio * z_dir_2d + r * r_dir_2d;
185  }
186 
187  Real val;
188  if (_has_component)
189  {
192 
193  // val_vec_rz contains the value vector converted from x,y to r,z coordinates
194  Point val_vec_rz;
195  val_vec_rz(0) = r_dir_2d(0) * val_x + r_dir_2d(1) * val_y;
196  val_vec_rz(1) = z_dir_2d(0) * val_x + z_dir_2d(1) * val_y;
197  if (!r_gt_zero && !MooseUtils::absoluteFuzzyEqual(val_vec_rz(0), 0.0))
198  mooseError("In Axisymmetric2D3DSolutionFunction r=0 and r component of value vector != 0");
199  Point val_vec_3d = val_vec_rz(0) * r_dir_3d + val_vec_rz(1) * z_dir_3d;
200 
201  val = val_vec_3d(_component);
202  }
203  else
205 
206  return _scale_factor * val + _add_factor;
207 }
const Real _add_factor
Factor to add to the solution (default = 0)
Base class for function objects.
Definition: Function.h:37
const std::vector< std::string > & variableNames() const
auto norm() const -> decltype(std::norm(Real()))
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:346
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)
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.
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
ADRealEigenVector< T, D, asd > sqrt(const ADRealEigenVector< T, D, asd > &)
const Number zero
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...
static InputParameters validParams()
Constructor.
virtual Real value(Real t, const Point &p) const override
Override this to evaluate the scalar function at point (t,x,y,z), by default this returns zero...
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...
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
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...
Real pointValue(Real t, const Point &p, const unsigned int local_var_index, const std::set< subdomain_id_type > *subdomain_ids=nullptr) const
Returns a value at a specific location and variable (see SolutionFunction)
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)
static InputParameters validParams()
Class constructor.
Definition: Function.C:15
const Real _scale_factor
Factor to scale the solution by (default = 1)
bool relative_fuzzy_equals(const TypeVector< Real > &rhs, Real tol=TOLERANCE) const
void ErrorVector unsigned int
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:392