ParsedCurveGenerator

This ParsedCurveGenerator object is designed to generate a mesh of a curve that consists of EDGE2 elements.

Overview

The ParsedCurveGenerator object generates a 3D curve mesh composed of EDGE2 elements which connect the series of points given by $var element = document.getElementById("moose-equation-c19999a0-56ca-47f0-97e7-ce47465a9bda");katex.render("[x(t),~y(t),~z(t)]", element, {displayMode:false,throwOnError:false});$ , where the range of t is specified by the user. The curve to be generated is described by the following equations,

(1)var element = document.getElementById("moose-equation-2271ea07-38d8-4ee0-a1ea-9136f580ab24");katex.render("\\begin{cases} x = x(t)\\\\ y = y(t)\\\\ z = z(t) \\end{cases},", element, {displayMode:true,throwOnError:false});

where, $var element = document.getElementById("moose-equation-581d541c-340d-427d-9c74-5e5b4ef27a8e");katex.render("x(t)", element, {displayMode:false,throwOnError:false});$ , $var element = document.getElementById("moose-equation-aff727ee-d282-4f6f-9754-7cda4ea75ed6");katex.render("y(t)", element, {displayMode:false,throwOnError:false});$ , and $var element = document.getElementById("moose-equation-a3589d7b-3954-49d4-a2a6-e804f20b5a99");katex.render("z(t)", element, {displayMode:false,throwOnError:false});$ are all provided in the form of C++ function parser through "x_formula", "y_formula", and "z_formula", respectively. The constants used in these formulae can be defined by "constant_names" and "constant_expressions".

Figure 1: A 3D open curve generated by ParsedCurveGenerator defined as $var element = document.getElementById("moose-equation-10919291-e650-4e33-86e2-5e67135257c6");katex.render("x(t)=\\cos t", element, {displayMode:false,throwOnError:false});$ ; $var element = document.getElementById("moose-equation-e914b94a-c71c-4883-8a39-2432e1592bfb");katex.render("y(t)=\\sin t", element, {displayMode:false,throwOnError:false});$ ; $var element = document.getElementById("moose-equation-610d6de5-0400-4586-b585-bc678738e974");katex.render("z(t)= t", element, {displayMode:false,throwOnError:false});$ with $var element = document.getElementById("moose-equation-15cc3e48-78af-4b45-a491-6f128a21ca6b");katex.render("t", element, {displayMode:false,throwOnError:false});$ ranging from $var element = document.getElementById("moose-equation-d6bd75c8-80cc-4c87-b470-958989b277e8");katex.render("0", element, {displayMode:false,throwOnError:false});$ to $var element = document.getElementById("moose-equation-42bafccc-e734-496f-a591-56c77ef8cee4");katex.render("4\\pi", element, {displayMode:false,throwOnError:false});$ .

Key $var element = document.getElementById("moose-equation-3b831d14-2bb9-46bf-a2b7-fa1d8b97bf8a");katex.render("t", element, {displayMode:false,throwOnError:false});$ values including the starting and ending values of $var element = document.getElementById("moose-equation-3d840711-1317-4d63-9e00-32329b8ffe27");katex.render("t", element, {displayMode:false,throwOnError:false});$ must be specified by "section_bounding_t_values". Optionally, intermediate $var element = document.getElementById("moose-equation-d074efbb-62de-4db5-81dc-aaa637b5ec91");katex.render("t", element, {displayMode:false,throwOnError:false});$ values can be added so that the curve can be divided into several sections. Note that the elements in "section_bounding_t_values" must be unique and change monotonically. Each interval defined by "section_bounding_t_values" must have a corresponding number of segments (i.e., EDGE2 elements), $var element = document.getElementById("moose-equation-23700637-37c4-4f21-bd27-95dece6beeac");katex.render("N_{seg}", element, {displayMode:false,throwOnError:false});$ , defined by "nums_segments".

Calculating Segment Division Points

Each section of the curve should ideally have segments of similar length. However, it is challenging to predict the corresponding $var element = document.getElementById("moose-equation-30a32f17-b16d-46d6-9fc5-f28da78a1959");katex.render("t", element, {displayMode:false,throwOnError:false});$ values that yield segments with similar length. Hence, oversampling is used to determine the $var element = document.getElementById("moose-equation-2a0c406e-eb67-4f6b-a08e-67f049bafe72");katex.render("t", element, {displayMode:false,throwOnError:false});$ values which result in consistent segment length. The oversampling factor $var element = document.getElementById("moose-equation-a5255fc2-4d24-4baa-8fc2-2a3c00c0cb15");katex.render("N_{os}", element, {displayMode:false,throwOnError:false});$ can be defined through "oversample_factor". Assuming that a section of curve is defined by $var element = document.getElementById("moose-equation-86dd2d9e-0367-449a-a2bc-f58b8055e4a2");katex.render("t_n", element, {displayMode:false,throwOnError:false});$ and $var element = document.getElementById("moose-equation-b1a08a0d-0653-4d6a-90c9-3f8e35c0666d");katex.render("t_{n+1}", element, {displayMode:false,throwOnError:false});$ , the distance between the starting and ending points of this section has the following form,

(2)var element = document.getElementById("moose-equation-65581993-b434-44dd-8044-39d5abf31145");katex.render("d_n = \\sqrt{\\left[x(t_n)-x(t_{n+1})\\right]^2+\\left[y(t_n)-y(t_{n+1})\\right]^2+\\left[z(t_n)-z(t_{n+1})\\right]^2}", element, {displayMode:true,throwOnError:false});

Thus, the oversampling target is to achieve that the maximum interval between neighboring sampling points is lower than a threshold value defined as follows,

(3)var element = document.getElementById("moose-equation-d53d092d-002c-4025-9b4f-100eef6cf27b");katex.render("d_{os,threshold} = \\frac{d_n}{N_{seg}N_{os}}", element, {displayMode:true,throwOnError:false});

The oversampling is realized by a binary algorithm, which divides oversized intervals in halves until all the intervals are shorter than $var element = document.getElementById("moose-equation-c0e29392-da45-4673-9c41-a24cddb6f3cf");katex.render("d_{os,threshold}", element, {displayMode:false,throwOnError:false});$ . Then the oversampled section points are used to determine the actual point locations (i.e., $var element = document.getElementById("moose-equation-1da29b3e-c25e-46f7-8335-cc2deaa748f6");katex.render("t", element, {displayMode:false,throwOnError:false});$ values).

Example Syntax

ParsedCurveGenerator is capable of generating both open and closed curves.

For open curve generation, the approach is straightforward with the example shown as follows.

Listing 1: the input syntax sample to generate an open logarithmic curve

[Mesh]
  [pcg]
    type = ParsedCurveGenerator
    x_formula = 't'
    y_formula = 'log10(1+9*t)'
    section_bounding_t_values = '0 1'
    nums_segments = 8
  []
[]

Figure 2: An open logarithmic curve generated by ParsedCurveGenerator.

On the other hand, for closed curve generation (defined by "is_closed_loop"), ideally the starting and ending values of $var element = document.getElementById("moose-equation-5431493b-3bca-4a17-8008-4fefd1f9def2");katex.render("t", element, {displayMode:false,throwOnError:false});$ should lead to the same $var element = document.getElementById("moose-equation-5a4bb181-0072-4d2c-b83c-241d82cccfcb");katex.render("x(t)", element, {displayMode:false,throwOnError:false});$ , $var element = document.getElementById("moose-equation-c3e6ee49-bdb2-4420-ad86-7391ec0abfda");katex.render("y(t)", element, {displayMode:false,throwOnError:false});$ , and $var element = document.getElementById("moose-equation-9d74e0ab-c344-4fd0-a86d-105cd46c2105");katex.render("z(t)", element, {displayMode:false,throwOnError:false});$ values, as shown below.

Listing 2: the input syntax sample to generate a closed half circular and half elliptical curve

[Mesh]
  [pcg]
    type = ParsedCurveGenerator
    x_formula = '1.0*cos(t)'
    y_formula = 'y1:=1.0*sin(t);
                 y2:=1.5*sin(t);
                 if(t<pi,y1,y2)'
    section_bounding_t_values = '0.0 ${fparse pi} ${fparse 2.0*pi}'
    nums_segments = '10 10'
    constant_names = 'pi'
    constant_expressions = '${fparse pi}'
    is_closed_loop = true
  []
[]

Figure 3: A closed half circular and half elliptical curve generated by ParsedCurveGenerator.

If the starting and ending values of $var element = document.getElementById("moose-equation-a91ebfb2-5997-4933-bd7c-f1330bc4a80f");katex.render("t", element, {displayMode:false,throwOnError:false});$ lead to different $var element = document.getElementById("moose-equation-a613c319-3382-4a12-9950-795ca8d785fb");katex.render("x(t)", element, {displayMode:false,throwOnError:false});$ , $var element = document.getElementById("moose-equation-8621d8f4-dc2b-4f9d-91e7-ced14376bdcd");katex.render("y(t)", element, {displayMode:false,throwOnError:false});$ , or $var element = document.getElementById("moose-equation-d8a716a3-f4ee-4142-a68a-95225e6d530b");katex.render("z(t)", element, {displayMode:false,throwOnError:false});$ values, the curve will be "forced" to close by directly connecting the starting and ending points (see Figure 4).

Figure 4: a fraction of the curve shown in Figure 3 forced to be closed.

By default, the curve section that closes the curve consists of only one EDGE2 element. However, users can also use "forced_closing_num_segments" to specify the number of elements in that curve section.

Used with Other Mesh Generators

If "z_formula" is set as zero (which is the default value), the generated curve resides in the XY-plane, and a pair of such ParsedCurveGenerator objects can naturally be connected by FillBetweenCurvesGenerator using FillBetweenPointVectorsTools.

Additionally, closed XY-plane curve meshes generated by ParsedCurveGenerator can be used by XYDelaunayGenerator as either "boundary" or "holes". See example below.

Listing 3: the input syntax sample to use ParsedCurveGenerator with XYDelaunayGenerator

[Mesh]
  [pcg]
    type = ParsedCurveGenerator
    x_formula = 'r*cos(t)'
    y_formula = 'y1:=r*sin(t);
                 y2:=b*sin(t);
                 if(t<pi,y1,y2)'
    section_bounding_t_values = '${fparse 0.0} ${fparse pi} ${fparse 2.0*pi}'
    constant_names = 'pi r b'
    constant_expressions = '${fparse pi} 1.0 1.5'
    nums_segments = '10 10'
    is_closed_loop = true
  []
  [hole1]
    type = ParsedCurveGenerator
    constant_names = 'th a b xs ys'
    constant_expressions = '${fparse pi/4.0} 0.25 0.5 0.1 0.3'
    x_formula = 'x0:=a*cos(t);
                 y0:=b*sin(t);
                 cos(th)*x0-sin(th)*y0+xs'
    y_formula = 'x0:=a*cos(t);
                 y0:=b*sin(t);
                 sin(th)*x0+cos(th)*y0+ys'
    section_bounding_t_values = '0.0 ${fparse 2.0*pi}'
    nums_segments = 18
    is_closed_loop = true
  []
  [hole2]
    type = ParsedCurveGenerator
    constant_names = 'th a xs ys'
    constant_expressions = '${fparse pi/2.0} 0.3 -0.1 -0.8'
    x_formula = 'x0:=a*(1+cos(t))*cos(t);
                 y0:=a*(1+cos(t))*sin(t);
                 cos(th)*x0-sin(th)*y0+xs'
    y_formula = 'x0:=a*(1+cos(t))*cos(t);
                 y0:=a*(1+cos(t))*sin(t);
                 sin(th)*x0+cos(th)*y0+ys'
    section_bounding_t_values = '0 ${fparse pi} ${fparse 2.0*pi}'
    nums_segments = '9 9'
    is_closed_loop = true
  []
  [xydg]
    type = XYDelaunayGenerator
    boundary = 'pcg'
    holes = 'hole1 hole2'
    add_nodes_per_boundary_segment = 1
    refine_boundary = false
    desired_area = 0.03
  []
[]

Figure 5: An example mesh generated by using ParsedCurveGenerator with XYDelaunayGenerator

Input Parameters

nums_segmentsNumbers of segments (EDGE2 elements) of each section of the curve to be generated. The number of entries in this parameter should be equal to one less than the number of entries in 'section_bounding_t_values'
C++ Type:std::vector<unsigned int>
Unit:(no unit assumed)
Controllable:No
Description:Numbers of segments (EDGE2 elements) of each section of the curve to be generated. The number of entries in this parameter should be equal to one less than the number of entries in 'section_bounding_t_values'
section_bounding_t_valuesThe 't' values that bound the sections of the curve. Start and end points must be included. The number of entries in 'nums_segments' should be equal to one less than the number of entries in this parameter.
C++ Type:std::vector<double>
Unit:(no unit assumed)
Controllable:No
Description:The 't' values that bound the sections of the curve. Start and end points must be included. The number of entries in 'nums_segments' should be equal to one less than the number of entries in this parameter.
x_formulaFunction expression of x(t)
C++ Type:std::string
Unit:(no unit assumed)
Controllable:No
Description:Function expression of x(t)
y_formulaFunction expression of y(t)
C++ Type:std::string
Unit:(no unit assumed)
Controllable:No
Description:Function expression of y(t)

Required Parameters

constant_expressionsVector of values for the constants in constant_names (can be an FParser expression)
C++ Type:std::vector<std::string>
Unit:(no unit assumed)
Controllable:No
Description:Vector of values for the constants in constant_names (can be an FParser expression)
constant_namesVector of constants used in the parsed function (use this for kB etc.)
C++ Type:std::vector<std::string>
Unit:(no unit assumed)
Controllable:No
Description:Vector of constants used in the parsed function (use this for kB etc.)
edge_nodesetsNodesets on both edges of the parsed curves
C++ Type:std::vector<BoundaryName>
Unit:(no unit assumed)
Controllable:No
Description:Nodesets on both edges of the parsed curves
epsilon1e-12Fuzzy comparison tolerance
Default:1e-12
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Fuzzy comparison tolerance
forced_closing_num_segmentsNumber of segments (EDGE2 elements) of the curve section that is generated to forcefully close the loop.
C++ Type:unsigned int
Unit:(no unit assumed)
Controllable:No
Description:Number of segments (EDGE2 elements) of the curve section that is generated to forcefully close the loop.
is_closed_loopFalseWhether the curve is closed or not.
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Whether the curve is closed or not.
max_oversample_number_factor1000For each section of the curve, the maximum number of oversampling points is the product of this factor and the number of nodes on the curve.
Default:1000
C++ Type:unsigned int
Unit:(no unit assumed)
Controllable:No
Description:For each section of the curve, the maximum number of oversampling points is the product of this factor and the number of nodes on the curve.
oversample_factor10Oversample factor to help make node distance nearly uniform.
Default:10
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Oversample factor to help make node distance nearly uniform.
point_overlapping_tolerance1e-06The point-to-point distance tolerance that is used to determine whether the two points are overlapped.
Default:1e-06
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:The point-to-point distance tolerance that is used to determine whether the two points are overlapped.
z_formula0Function expression of z(t)
Default:0
C++ Type:std::string
Unit:(no unit assumed)
Controllable:No
Description:Function expression of z(t)

Optional Parameters

control_tagsAdds user-defined labels for accessing object parameters via control logic.
C++ Type:std::vector<std::string>
Unit:(no unit assumed)
Controllable:No
Description:Adds user-defined labels for accessing object parameters via control logic.
enableTrueSet the enabled status of the MooseObject.
Default:True
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Set the enabled status of the MooseObject.
save_with_nameKeep the mesh from this mesh generator in memory with the name specified
C++ Type:std::string
Unit:(no unit assumed)
Controllable:No
Description:Keep the mesh from this mesh generator in memory with the name specified

Advanced Parameters

disable_fpoptimizerFalseDisable the function parser algebraic optimizer
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Disable the function parser algebraic optimizer
enable_ad_cacheTrueEnable caching of function derivatives for faster startup time
Default:True
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Enable caching of function derivatives for faster startup time
enable_auto_optimizeTrueEnable automatic immediate optimization of derivatives
Default:True
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Enable automatic immediate optimization of derivatives
enable_jitTrueEnable just-in-time compilation of function expressions for faster evaluation
Default:True
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Enable just-in-time compilation of function expressions for faster evaluation
evalerror_behaviornanWhat to do if evaluation error occurs. Options are to pass a nan, pass a nan with a warning, throw a error, or throw an exception
Default:nan
C++ Type:MooseEnum
Unit:(no unit assumed)
Options:nan, nan_warning, error, exception
Controllable:No
Description:What to do if evaluation error occurs. Options are to pass a nan, pass a nan with a warning, throw a error, or throw an exception

Parsed Expression Advanced Parameters

nemesisFalseWhether or not to output the mesh file in the nemesisformat (only if output = true)
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Whether or not to output the mesh file in the nemesisformat (only if output = true)
outputFalseWhether or not to output the mesh file after generating the mesh
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Whether or not to output the mesh file after generating the mesh
show_infoFalseWhether or not to show mesh info after generating the mesh (bounding box, element types, sidesets, nodesets, subdomains, etc)
Default:False
C++ Type:bool
Unit:(no unit assumed)
Controllable:No
Description:Whether or not to show mesh info after generating the mesh (bounding box, element types, sidesets, nodesets, subdomains, etc)

Debugging Parameters

(moose/test/tests/meshgenerators/parsed_curve_generator/parsed_curve_open.i)

[Mesh]
  [pcg]
    type = ParsedCurveGenerator
    x_formula = 't'
    y_formula = 'log10(1+9*t)'
    section_bounding_t_values = '0 1'
    nums_segments = 8
  []
[]

(moose/test/tests/meshgenerators/parsed_curve_generator/parsed_curve_closed.i)

[Mesh]
  [pcg]
    type = ParsedCurveGenerator
    x_formula = '1.0*cos(t)'
    y_formula = 'y1:=1.0*sin(t);
                 y2:=1.5*sin(t);
                 if(t<pi,y1,y2)'
    section_bounding_t_values = '0.0 ${fparse pi} ${fparse 2.0*pi}'
    nums_segments = '10 10'
    constant_names = 'pi'
    constant_expressions = '${fparse pi}'
    is_closed_loop = true
  []
[]

(moose/test/tests/meshgenerators/parsed_curve_generator/xy_curve.i)

[Mesh]
  [pcg]
    type = ParsedCurveGenerator
    x_formula = 'r*cos(t)'
    y_formula = 'y1:=r*sin(t);
                 y2:=b*sin(t);
                 if(t<pi,y1,y2)'
    section_bounding_t_values = '${fparse 0.0} ${fparse pi} ${fparse 2.0*pi}'
    constant_names = 'pi r b'
    constant_expressions = '${fparse pi} 1.0 1.5'
    nums_segments = '10 10'
    is_closed_loop = true
  []
  [hole1]
    type = ParsedCurveGenerator
    constant_names = 'th a b xs ys'
    constant_expressions = '${fparse pi/4.0} 0.25 0.5 0.1 0.3'
    x_formula = 'x0:=a*cos(t);
                 y0:=b*sin(t);
                 cos(th)*x0-sin(th)*y0+xs'
    y_formula = 'x0:=a*cos(t);
                 y0:=b*sin(t);
                 sin(th)*x0+cos(th)*y0+ys'
    section_bounding_t_values = '0.0 ${fparse 2.0*pi}'
    nums_segments = 18
    is_closed_loop = true
  []
  [hole2]
    type = ParsedCurveGenerator
    constant_names = 'th a xs ys'
    constant_expressions = '${fparse pi/2.0} 0.3 -0.1 -0.8'
    x_formula = 'x0:=a*(1+cos(t))*cos(t);
                 y0:=a*(1+cos(t))*sin(t);
                 cos(th)*x0-sin(th)*y0+xs'
    y_formula = 'x0:=a*(1+cos(t))*cos(t);
                 y0:=a*(1+cos(t))*sin(t);
                 sin(th)*x0+cos(th)*y0+ys'
    section_bounding_t_values = '0 ${fparse pi} ${fparse 2.0*pi}'
    nums_segments = '9 9'
    is_closed_loop = true
  []
  [xydg]
    type = XYDelaunayGenerator
    boundary = 'pcg'
    holes = 'hole1 hole2'
    add_nodes_per_boundary_segment = 1
    refine_boundary = false
    desired_area = 0.03
  []
[]

Overview
Calculating Segment Division Points
Example Syntax
Used with Other Mesh Generators
Input Parameters