Level Set Specifications¶
Fill Subcycle¶
Fill Subcycle = <integer>
Description / Usage¶
This is an optional card that sets the number of subcycle-fill time steps between fluidflow time steps in uncoupled level set calculations. The default is 10 subcycle time steps for every flow time step. The input parameter is defined as
- <integer>
Any nonzero number indicating the subcycling frequency of the fill equation versus the flow equations.
For example, if the value of <integer> is 1, the flow and fill equations are solved every time step. If it is 10, between every transient step in the flow calculation, the fill (advection) equation is solved 10 times with one-tenth of the time step.
References¶
GT-020.1: Tutorial on Level Set Interface Tracking in GOMA, Februray 27, 2001, T.A. Baer
Fill Weight Function¶
Fill Weight Function = {Galerkin | Taylor-Galerkin | SUPG}
Description / Usage¶
Sets the weight function used for the FILL equation for either the VOF or Level Set methods. The options for this card are as follows:
- Galerkin
Name of the weight function formulation. This option requests a standard Galerkin finite element weighted residual treatment. A floating point parameter is not used for this option.
- Taylor-Galerkin
Name of the weight function formulation
- SUPG
Name of the weight function formulation. This option requests a Streamwise Upwinding Petrov Galerkin formulation. No floating point parameter is required.
The default value for the Fill Weight Function is Taylor-Galerkin.
Technical Discussion¶
This card selects the integration/weight function used in solving for the VOF color function or the level set distance function (i.e., the FILL unknown). The user should refer to the tutorial on Level Set Computations for a detailed description of level set interface tracking. (See References.)
References¶
GT-020.1: Tutorial on Level Set Interface Tracking in GOMA, February 27, 2001, T.A. Baer
A. N. Brooks and T. J. R. Hughes, “Streamline Upwind/Petrov-Galerkin Formulations for Convection Dominated Flows with Particular Emphasis on the Incompressible Navier-Stokes Equations,” Comp. Math. In Appl. Mechanics and Eng., 32, 199 - 259 (1992).
A. J. A. Unger, P. A. Forsyth and E. A. Sudicky, “Variable spatial and temporal weighting schemes for use in multi-phase compositional problems,” Advances in Water Resources, 19, 1 - 27 (1996).
R. Helmig and R. Huber, “Comparison of Galerkin-type discretization techniques for two-phase flow in heterogeneous porous media,” Advances in Water Resources, 21, 697-711 (1998).
E. Gundersen and H. P. Langtangen, “Finite Element Methods for Two-Phase Flow in Heterogeneous Porous Media,” in Numerical Methods and Software Tools in Industrial Mathematics, Morten Daehlen, Aslak Tveito, Eds., Birkhauser, Boston, 1997.
S. F. Bradford and N. D. Katopodes, “The anti-dissipative, non-monotone behavior of Petrov-Galerkin Upwinding,” International J. for Numerical Methods in Fluids, v. 33, 583-608 (2000).
Level Set Interface Tracking¶
Level Set Interface Tracking = {yes | no}
Description / Usage¶
Activates (or deactivates) embedded interface tracking by the level set method. When activated, the set of cards specifying level set run parameters are read; these should appear in the input deck following this card. Also when activated a “level_set” equation type should be included in the list of equations identified in the equations section.
References¶
GT-020.1: Tutorial on Level Set Interface Tracking in GOMA, February 27, 2001, T.A. Baer
Level Set Semi_Lagrange¶
Level Set Semi_Lagrange = <char1>
Description / Usage¶
This card is currently inactive because it was developed for decoupled LS fill problems.
- <char1>
YES | ON | TRUE
Examples¶
Level Set Semi_Lagrange = yes
Level Set Subgrid Integration Depth¶
Level Set Subgrid Integration Depth = <integer1>
Description / Usage¶
Subgrid integration is used to improve integration accuracy for all functions which invoke a diffuse level-set interface representation of properties and surfaces. With integration depths greater than zero the elements through which the zero level set crosses are subdivided in a geometric way to achieve more accurate integration. Level- 1 depths implies the smallest grid size is 1/4 of the original, and a level-2 is 1/8th, and so on. Please see usage nodes below.
- <integer1>
Level of integration depth. Default is zero. See usage notes.
Examples¶
This example sets the subgrid integration depth to two:
Level Set Subgrid Integration Depth = 2
Technical Discussion¶
Each level of subgrid integration leads to precipitous growth in computational load, especially in 3D. Level-2 seems to optimize accuracy and efficiency. Levels higher than 2 is not recommended.
References¶
GT-020.1: Tutorial on Level Set Interface Tracking in GOMA, February 27, 2001, T.A. Baer
Level Set Subelement Integration¶
Level Set Subelement Integration = {ON | YES | OFF | NO}
Description / Usage¶
Subelement integration is used to improve integration accuracy for all functions which invoke a sharp level-set interface. Note here that the Level Set Length Scale option must be zero. This is possible because the subelement integration scheme actually produces a geometric representation of the zero level set surface on which exact line integrals of the surface tension source term term can be peformed. Please see usage nodes below.
- {ON | YES}
Use subelement integration on surface level set capillary term.
- {OFF | NO}
Don’t use subelement integration.
Technical Discussion¶
NOTE: Level Set Length Scale must be set to zero.
Because of the construction of an in-element interface meshing to find this representation, subelement integration cannot be used currently for three dimensional problems. Subgrid integration can be, however, but it is inefficient.
Best to use this integration approach with the property specification method of “Second Level-Set “property_name”, e.g. Second Level Set Density, etc.
Typically this capability greatly improves mass conservation and avoids parasitics for surface tension dominated problems.
NOTE that the Level Set Renormalization method must be set to Huygens.
References¶
GT-020.1: Tutorial on Level Set Interface Tracking in GOMA, February 27, 2001, T.A. Baer
Level Set Adaptive Integration¶
Level Set Adaptive Integration = {ON | YES | OFF | NO}
Description / Usage¶
To be used with Subelement integration to improve integration accuracy. Does not work with subgrid integration or basic level-set. Requires a sharp interface, viz. levelset length scale of zero. Please see usage nodes below.
- {ON | YES}
Use adaptive integration on surface level set capillary term.
- {OFF | NO}
Don’t use adaptive integration.
References¶
GT-020.1: Tutorial on Level Set Interface Tracking in GOMA, February 27, 2001, T.A. Baer
Level Set Adaptive Order¶
Level Set Adaptive Integration = <integer1>
Description / Usage¶
To be used with Subelement adaptive integration to improve integration accuracy. Does not work with subgrid integration or basic level-set. Requires a sharp interface, viz. level-set length scale of zero. Please see usage nodes below.
- <integer1>
Adaptive integration order. Single positive integer greater than zero. Default value is 3.
Examples¶
This example invokes the subelement adaptive integration order:
Level Set Adaptive Integration = YES
Level Set Adaptive Order = 2
References¶
GT-020.1: Tutorial on Level Set Interface Tracking in GOMA, February 27, 2001, T.A. Baer
Overlap Quadrature Points¶
Overlap Quadrature Points = <integer1>
Description / Usage¶
To be used with the overset grid capability. This function sets the number of overlap quadrature points with this capability. See GT-026 for more details.
- <integer1>
Overlap quadrature points. Single positive integer greater than zero. Default value is 3.
Examples¶
This example invokes the number of overlapping quadrature points:
Overlap Quadrature Points = 2
Technical Discussion¶
Please consult the overset grid capability tutorial for futher discussion. (Ref. below). This is to be use with AC_OVERLAP, or the augmenting condition of type AC = OV.
References¶
GT-026.4: “GOMA’s Overset Mesh Method”, P R. Schunk and E. D. Wilkes, 11 Jan. 2006
Level Set PSPP Filtering¶
Level Set PSPP filtering = <YES | NO>
Description / Usage¶
On this card, the user specifies a single char_string.
- <YES | ON>
This string turns on level set PSPP filtering if it is “yes” or “on”.
Technical Discussion¶
Not entirely clear what this card does, but in the vicinity of the level-set interface, the Bochev PSPP stabilization scheme is altered. This is recommended when this pressure stabilization scheme is deployed. See the Pressure Stabilization card.
Level Set Length Scale¶
Level Set Length Scale = <float>
Description / Usage¶
On this card, the user specifies a single char_string.
- <float>
This value represents the size of the region around the zero level set function contour in which interfacial physical quantities, for example, surface tension, will be present.
Stability and conservation of phase volume are dependent upon this value to a significant degree. Experimentation has revealed that this float value should be between two and three times the average linear dimension of the elements in the mesh.
Technical Discussion¶
The level set method is an embedded interface method. That is, the location of the interface is not known explicitly as a geometric parameter of the problem, but rather it is abstracted as a level contour of a higher dimensional function. This is convenient in many ways, but it does mean that phenomena associated with the interface, for example, surface tension, must enter the problem spread over a region near the zero level set contour. The Level Set Length Scale sets the size of this region.
A good example of the application of the Level Set Length Scale parameter is in how surface tension is included in problems using level set interface tracking. The following tensor is added to the fluid momentum equation:
where \(F\) is the level set function itself, \(\underline{n}\) is the unit normal to the level set contour, \(\underline{\underline{I}}\) is the unit tensor, \(\sigma\) the surface tension, and \(\delta_{\alpha} \left( F \right)\) is a “smooth” Dirac function given by:
In this example, the parameter \(\alpha\) would be equal to one-half the Level Set Length Scale value specified on this card.
FAQs¶
How should the Length Scale value be chosen? Trial and error is often the best method to determine an appropriate value for this parameter. However, experience has shown that values for Level Set Length Scale that are between two and three times the average element linear dimension seem to work best.
References¶
GT-020.1: Tutorial on Level Set Interface Tracking in GOMA, February 27, 2001, T.A. Baer
Level Set Initialize¶
Level Set Initialize = <char_string> <float1> <float2>
Description / Usage¶
This card is used to initialize fields around the zero level set.
- <Char_string>
A character string which identifies dependent variable to be initialized. It is taken from the list of names on the Initialize card.
- <float1>
Value of the variable on the negative side of the zero level set.
- <float2>
Value of the field on the positive side of the zero level set.
Examples¶
Two examples of initialization methods are provide below:
Level Set Initialize = TEMPERATURE 0. 100.
Technical Discussion¶
Not clear whether this capability has been used and tested much. (12/3/2012)
Level Set Initialization Method¶
Level Set Initialization Method = {method_name} {parameter list}
Description / Usage¶
This card specifies the means by which the level set function is initialized. That is, it constructs from a representation of the starting interface shape, a value for the distance function at every node in the mesh. The syntax of the card is as follows:
- {method_name}
A character string which identifies the initialization option desired. Choices for this string are: Projection, Exodus, Nodeset, Surfaces, SM_object.
- {parameter list}
This is a variable parameter list specific to each option. The nature of it for each method is detailed in the syntax descriptions below.
Below are the exact syntax used for each initialization method, a brief description of the method and a specification of any additional required parameters.
Projection |
This method computes the initial level set field by calling a user-specified routine which returns the signed distance function for a given point. It has no parameter list after its name. |
Exodus |
Using this card indicates that the initial level set field is to be read from the exodus file specified earlier (see FEM file and Initial Guess cards for read_exoII option). This card has no parameter list after its name. |
Nodeset <integer1> EB <integer2> |
This method establishes the initial location of the interface as the boundary between two element blocks. The value <integer1> is the nodeset identification number for an internal nodeset defined to exist at the interface between the two element blocks. The character string EB is required. The integer <integer2> is the element block id number to which positive values of level set function is going to be assigned. |
Surfaces <integer> |
This card establishes the initial level set function by referring to a set of primitive geometric objects. It is the easiest to use and the most general. The integer value <integer> is the number of surface objects that are used to construct the initial interface. This number of SURF object cards must follow this card. This is the syntax of the SURF object card: SURF = {object_name} {float list} {object_name}: a character string identifying the type of geometric object. Options are: PLANE, CIRCLE, SPHERE, SS, USER. {float list}: geometric parameters associated with each object as float values |
The following is the syntax and description for each geometric object option, i.e., the “{object_name} {float list}” part of SURF
PLANE <nx. <ny> <nz> <d> |
This card constructs a planar interface surface. The float values <nx>, <ny>, <nz> define a vector normal to this plane with the restriction that the sign of the vector must be such that it points from the negative side of the interface to the positive side of the interface. The float value <d> effectively represents the distance of the plane from the origin. Its value must be set, however, so that the dot product of any position vector to a point on the desired plane and the vector (nx,ny,nz) must be equal to <d> (it is a property of planes that this number is independent of the point on the plane that is chosen). |
CIRCLE <cx> <cy> <radius> |
This card constructs a circular interface surface in a two-dimensional domain. The float values <cx> <cy> identify the coordinates of the center of the circle. The float value <radius> establishes the radius of the curve. By definition, points interior to the circle are assigned negative level set function values. |
SPHERE <cx> <cy> <cz> <radius> |
This card constructs a spherical interface surface in a three-dimensional domain. The float values <cx> <cy> <cz> identify the coordinates of the center of the circle. The float value <radius> establishes the radius of the sphere. By definition, points interior to the sphere are assigned negative level set function values. |
SS {ss_id} |
This card uses an existing sideset in the problem as a defined geometric object for construction of an interface. The parameter <ss_id> identifies this sideset. |
USER {user-defined float list} |
This card indicates the user has defined an object function using the supplied parameter float list that returns a signed distance value when supplied with the coordinates of a point in space. This object function should appear in the function call user_init_object in the file user_pre.c. |
SM_object {object_type} {object_name} |
This card allows the user to initialize the level set location by using a piece of solid model geometry. The solid model object_type can be either FACE or BODY. A 2D initialization uses the boundary of the specified FACE (or surface) as the 0 level set. A 3D initialization uses the boundary of the specified BODY (or volume) as the 0 level set. |
Examples¶
Two examples of initialization methods are provide below:
Level Set Initialization Method = Nodeset 20 EB 1
Level Set Initialization Method = Surfaces 3
SURF = PLANE -1. 0. 0. -3.
SURF = CIRCLE -2 0 1
SURF = CIRCLE -3 0 0.5
Level Set Initialization Method = SM_object BODY my_blob
Technical Discussion¶
The Projection initialization method was developed early in the level set development process. It has since been superseded by other more easily used methods. It is still supported primarily for the use of developers. Users wanting a complicated interface shape for which they can supply an appropriate distance function should user the USER surface object option under the Surfaces initialization method.
The Exodus method deserves little comment. It should be used when restarting level set computations from a preexisting solution.
The Nodeset method allows the user to make use of the sophisticated solid body manipulation software in meshing packages like CUBIT. The procedure for using this method is to create a domain which contains two element blocks. The desired starting point for the interface should lie on the curve or surface which these two blocks have in common. A single nodeset should be defined over this entire curve or surface. The nodeset identification number should be the first integer parameter specified on the card. Also note that one of the blocks must be designated as the “positive” block. This means then when initialized the values of the level set function in this block will be positive. The values in the other block will be negative. Note that this initialization method can only by used for problems that have exactly two blocks, no more.
The Surfaces initialization method is the most useful method for initialization. It draws from the fact that it is relatively easy to determine the distance to simple geometric objects (planes, circles, spheres, etc.). Further, it permits initialization using more than one of these objects so that relatively complicated initial interface locations can be constructed. However, the user should recognize that this method is still somewhat unsophisticated in its approach so there are some caveats associated with its use. The primary point is that surface objects should never intersect anywhere within the domain of interest, otherwise it is more than likely that the starting interface shape will not be what the user expects.
The SM_object initialization method allows the user to use solid model geometry to initialize 2D and 3D level sets. Certain 2D geometries can be created using only Goma input commands (see FACE). Other 2D geometries, and all 3D geometries, can be accessed via an ACIS .sat file. The usual way to do this is for the user to create their desired geometry within Cubit (or, import solid model geometry from elsewhere into Cubit). Faces (or surfaces) should be created for 2D initialization, and bodies (or volumes) should be created for 3D initialization. The boundary of the object is used to initialize the level set. The geometry should be named within Cubit and exported to an ACIS .sat file via Cubit’s export acis “filename” ascii command. This same file should be read in via the ACIS file command in the Geometry Specifications section. The solid model geometry is then available for the Level Set Initialization Method command. (Note that the Geometry Specifications section usually comes after the Level Set Initialization Method command; this is OK).
References¶
GT-020.1: Tutorial on Level Set Interface Tracking in GOMA, February 27, 2001, T.A. Baer
Level Set Periodic Planes¶
Level Set Periodic Planes = <float1> <float2> <float3> <float4> <float5> <float6>
Description / Usage¶
This card directs the level-set renormalization to accommodate peroidic boundary conditions (see Advanced Capabilities Manual AC_Periodic capability). The periodic boundary conditions on the level set field are not compatible with renormalization unless this capability is specified.
- <float1>
x-coordinate value of first periodic boundary.
- <float2>
x-coordinate value of second periodic boundary. If equivalent to float1 than this direction is not periodic.
- <float3>
y-coordinate value of first periodic boundary.
- <float4>
y-coordinate value of second periodic boundary. If equivalent to float3 than this direction is not periodic.
- <float5>
y-coordinate value of first periodic boundary.
- <float6>
y-coordinate value of second periodic boundary. If equivalent to float5 than this direction is not periodic.
Examples¶
Two examples of initialization methods are provide below:
Level Set Periodic Boundary = -0.5 0.5 0 0 0 0
This card instructs renormalization to accommodate the x-directed-boundaries to be considered as periodic relative to the level-set field.
References¶
GT-020.1: Tutorial on Level Set Interface Tracking in GOMA, February 27, 2001, T.A. Baer
Level Set Control Width¶
Level Set Control Width = <float>
Description / Usage¶
This card is a multiplier on the Level Set Length Scale to determine the size of the region around the zero level set contour over which the level set gradient is averaged. The value of this parameter defaults to 1.0 if this card is not included.
Examples¶
This sample card sets the control width to be equivalent to the length scale:
Level Set Control Width = 0.5
Technical Discussion¶
As noted in the description of the Level Set Renormalization Tolerance card, renormalization is triggered when the average of the level set gradient magnitude has departed sufficiently from unity. The region over which this average is obtained is approximately a narrow fixed-width strip on either side of the zero level set contour. The width of this strip is twice the Level Set Length Scale multiplied by the float value supplied on this card.
FAQs¶
Usually it is best practice to leave this parameter at its default setting and control the frequency of renormalization with the renormalization tolerance.
Level Set Timestep Control¶
Level Set Timestep Control = <YES | NO>
Description / Usage¶
On this card, the user specifies a single char_string.
- <YES | ON>
This string turns on level set timestep control if it is “yes” or “on”.
Technical Discussion¶
In normal operations, the error norm of the level set function is not included in controlling the size of the time step decided upon by the variable timestep size integrator. Inclusion of this card will add the level set unknown to the list of update error norms used to decide the time step size. In other words, use this card when you want the changes of the level set function to affect the timestep size. If this card is not used, the default behavior is to ignore the level set degrees of freedom in controlling the timestep size.
Level Set Renormalization Tolerance¶
Level Set Renormalization Tolerance = <float>
Description / Usage¶
This parameter provides a means for controlling how often renormalization (redistancing) operations are performed on the level set function as it evolves by fixing the size of the deviation allowed between the average absolute magnitude of the level set function gradient near the level set interface and unity, the theoretical value observed for a pure distance function.
- <float>
Value of the tolerance, the allowable deviation.
The range of this parameter is any positive real number, however, it is rare to use values smaller than 0.1 or larger than 5.0. The value of the tolerance defaults to 0.5 if this card is not specified.
Technical Discussion¶
One of the key properties of the level set function is that it is a smooth function near to the interface. In particular, if the level set function is a distance function then the magnitude of its gradient on the zero level contour should always be unity. This fact is used to provide a criterion for invoking a renormalization procedure. The gradient of the level set function is found within a fixed region around the zero level set contour (see Level Set Control Width). The integrated average of the magnitude of this vector is determined and compare to unity. Should this difference differ by greater than the value for Renormalization Tolerance identified on this card, a renormalization procedure will presently be initiated.
FAQs¶
What is a proper value for this parameter? Values on the order of unity should work well. Renormalization based on gradient can be disabled completely by choosing a very large value for this parameter. Conversely, a very small value will always result in a renormalization step.
Is it possible to renormalize too often? Yes. Renormalization is an extraphysical procedure designed solely to improve the numerical performance of the interface tracker. As such, it can add or subtract volume to or from the phases represented by the interface contour. Renormalizing too often, therefore, can result in errors being introduced. The renormalization procedure, Huygens_Constrained, attempts to mitigate this effect.
Level Set Renormalization Method¶
Level Set Renormalization Method = {char_string}
Description / Usage¶
This card indicates the method to be used to renormalize the level set function during the course of the computation. The syntax of this card is as follows:
- {char_string}
A character string which specifies the type of method for renormalization. Choices for this string are: Huygens, Huygens_Constrained, Correction.
Each method is described below; see also the Technical Discussion.
- Huygens
In this method a set of m points P is constructed:
\(\mathbf{P} = \left\{ \left( x_i, y_i, z_i \right), \, i = 1,2, \ldots m | \quad \phi_j \left( x_i, y_i, z_i \right) = 0 \right\}\)
which in a sense represent a discretization of the interface location. The finite element interpolation functions are used to find exact locations for these points. For each mesh node \(j\), a minimum distance \(D_j\), can be found to this set of points. Renormalization is accomplished by replacing the level set value at this node \(\phi_j\) with \(D_j\) multiplied by the sign of the previous value for the level set function. This method is fast and robust and reasonably accurate given sufficiently refined meshes using high order level set interpolation. However, this method is prone to losing material if low order level set interpolation is employed.
- Huygens_Constrained
This method renormalizes the function in much the same way as the Huygens method, except it employs a Lagrange multiplier to enforce a global integrated constraint that requires the volume occupied by the “negative” phase to remain unchanged before and after renormalization. This requirement makes this method better at conserving mass. However, since it enforces a global constraint, it is possible that material might be moved nonphysically around the computational domain.
Examples¶
This is a sample renormalization method input card:
Level Set Renormalization Method = Huygens_Constrained
Technical Discussion¶
Renormalization is an operation particular to level set embedded interface tracking. The level set function \(\phi\) is usually specified in terms of a signed distance to the interface. This type of function has very nice properties in terms of smoothness and a unitary gradient magnitude in the vicinity of the interface. All of which are beneficial in accurately integrating the function and applying interfacial physics such as surface tension. The difficulty appears because of the velocity field \(\underline{u}\) used to evolve the level set function via the relation:
There is nothing that requires that this velocity preserve the level set function as a distance function during its evolution. As a result, large gradients in the level set function might appear that would degrade the accuracy of both its time evolution and the accuracy of the interfacial terms related to the level set function. To remedy this problem, periodically the level set function must be reconstructed as a distance function; this process is referred to as renormalization. The criteria for determining when renormalization should occur is discussed under Level Set Renormalization Tolerance.
Level Set Renormalization Frequency¶
Level Set Renormalization Frequency = <integer>
Description / Usage¶
This card sets an upper limit to the number of time steps which are allowed to pass between renormalization procedures. Possible values for <integer> are listed below:
<integer>
-1
never renormalize (default)
0
renormalize every step
n
a positive integer >1, renormalize every n^{th} time step
Technical Discussion¶
Renormalization procedures are normally triggered by the average gradient exceeding one by a specified amount (see Level Set Renormalization Tolerance). However, at times it might be advantageous to trigger a renormalization independent of the size of the average level set gradient. For example, it might occur that in a very small region near the interface, the level set gradient is becoming large but elsewhere the gradient is still relatively small. Since the average gradient is used, this condition might not trigger renormalization. By setting an upper limit for the number of time steps that can pass before renormalization, situations such as this can be remedied.
Restart Time Integration After Renormalization¶
Restart Time Integration After Renormalization = {yes | no}
Description / Usage¶
This card is used to specify whether or not to restart time integration each time Goma renormalizes the level set function during the course of the computation. When time integration is restarted, the time step is reset to its initial size and held at this step size for the following 3 time steps. If this card is not present, the default is yes (time integration will be restarted after each renormalization). The syntax of this card is as follows:
- {yes | no}
Indicates the specified choice. {yes | on | true}can all be used to specify restarting of time integration. {no | off | false} can all be used to specify no restart.
Examples¶
This is a sample renormalization method input card:
Restart Time Integration After Renormalization = no
Level Set Reconstruction Method¶
Level Set Reconstruction Method = {char_string}
Description / Usage¶
This card indicates the method used to perform the Huygens renormalization of the level set function. This card applies only if Level Set Renormalization Method is set to Huygens or Huygens_Constrained. Permissible values of {char_string} are:
- POINTS
A list of points on the interface is formed and the renormalized distance is computed as the distance to the nearest point in this list; this is the default method.
- FACETS
A list of connected facets on the interface is formed and the renormalized distance is computed as the distance to the nearest point on the nearest facet in this list. Currently this option is not supported for 3-dimensional calculations.
Technical Discussion¶
As described for the Level Set Renormalization Method card, Huygens based renormalization is performed by reconstructing the level set surface and computing the distance to the nearest point on this surface. Here, the method of reconstructing the level set surface is addressed. Either a set of points on the interface is formed or a connected set of facets is formed. The advantage to using connected facets is that the interface is better described between the points on the interface. However, the calculation of the faceted geometry is slightly more expensive computationally. Also, the current implementation is limited to 2-dimensional simulations.
Level Set Contact Extension¶
Level Set Contact Extension = {yes|no}
Description / Usage¶
This card specifies whether the level set surface is considered to extend into boundaries when performing renormalization of the level set distance function. This card applies only if Level Set Renormalization Method = Huygens_Constrained. Permissible values for this option are:
- yes|on
The level set interface is considered to extend smoothly into the boundaries.
- no|off
The level set interface ends at the boundaries; this is the default.
Technical Discussion¶
When renormalizing the level set distance function, the behavior of the interface near boundaries is important. When the interface is considered to end at the boundary, a large number of grid points may be closest to this boundary point. This appears as a cusp in the interface and can make it difficult to achieve sharp contact angles because of the very large capillary force that results. One method to alleviate this is to extend the interface smoothly into the boundaries to eliminate the cusp in the interface. The current algorithm, however, can cause errors when employed near corners of the domain. Until this is resolved, this option can only be recommended for domains without interior corners.
Level Set Slave Surface¶
Level Set Slave Surface = {yes|no}
Description / Usage¶
This card specifies whether the level set distance function is constrained during the calculation or evolves with the typical advection equation. Permissible values for this option are:
- yes|on
The surface is constrained to remain on the initial surfaces throughout the calculation (moving with these surfaces if they are moving).
- no|off
The surface evolves normally according to the local velocity field; this is the default.
Technical Discussion¶
In a typical level set simulation, the surface is first initialized with the Level Set Initialization Method card, and then the surface evolves in time according to the local velocity field. Using this card, however, the surface is constrained to remain on the initial surfaces. If the initial surfaces are static, then the level set surface remains stationary. For moving interfaces such as those defined by an isosurface or a side set, the level set function is reinitialized at each Newton iteration to match the moving surface.
References¶
GT-020.1: Tutorial on Level Set Interface Tracking in GOMA, February 27, 2001, T.A. Baer
Ignore Level Set Dependencies¶
Ignore Level Set Dependencies = {yes | no}
Description / Usage¶
Including this card in your input deck with the string parameter set to “yes” instructs Goma to discard the sensitivities of all equations to the level set variable when constructing the Jacobian matrix. This may have benefits when it comes to stability and convergence; although, the effectiveness of this card is very much case by case. Note also that use of this card is consistent only with Fill Weight Function = Explicit. Any other choice will result in an error.
Force Initial Level Set Renormalization¶
Force Initial Level Set Renormalization = <char_string>
Description / Usage¶
This card is used to invoke a renormalization step prior to the first time step of any transient computation.
- <char_string>
YES|ON
(not case sensitive) will cause the renormalization procedure to occur on the first step. If this card is not included or some other string is used here a renormalization will automatically occur on the first time step.
Examples¶
A typical length scale input card looks like:
Force Initial Level Set Renormalization = yes
Technical Discussion¶
Restarts occur fairly frequently during level set computations. It has been discovered that the robustness of the subsequent computation can be improved by quite a bit if the level set field is renormalized at the start of the restart, regardless of the current average gradient norm error. This card is employed to invoke a renormalization at the start of any computation, that is, a renormalization procedure is conducted prior to the initial time step if this card is present in the input deck. It has become standard operating procedure that when a level set computation runs into computational difficulty the first step in recovery should be to restart with a forced initial renormalization using this card.