Go to the source code of this file.
Data Structures | |
| struct | Cleanup |
| This function "removes" (by setting their volume fraction to zero) cells which have inconsistent volume/surface fractions. More... | |
Macros | |
| #define | BGHOSTS 2 |
| #define | EMBED 1 |
| #define | SEPS 1e-30 |
| Embedded boundary operators specific to trees are defined in this file. | |
| #define | cs_avg(a, i, j, k) |
| When combining third-order Dirichlet conditions and approximate projections, instabilities may occur due to feedback between the pressure mode and the velocity, amplified by the third-order derivative. | |
| #define | face_condition(fs, cs) |
| Face gradients and face values, computed from cell-centered values must be tuned to take into account the area fractions of the embedded boundary. | |
| #define | face_gradient_x(a, i) |
| #define | face_gradient_y(a, i) |
| #define | face_gradient_z(a, i) |
| #define | face_value(a, i) |
| #define | center_gradient(a) |
| The centered gradient must not use values of fields entirely contained within the embedded boundary (for which cs is zero). | |
| #define | embed_pos() embed_area_center (point, &x, &y, &z) |
| #define | quadratic(x, a1, a2, a3) (((a1)*((x) - 1.) + (a3)*((x) + 1.))*(x)/2. - (a2)*((x) - 1.)*((x) + 1.)) |
Functions | |
| for (int _d=0;_d< 2;_d++) static inline double embed_face_gradient_x(Point point | |
| assert (cs[i] &&cs[i-1]) | |
| if ((fs .x[i, j] > 0.5 &&fs .y[i, j+(j< 0)] &&fs .y[i-1, j+(j< 0)] &&cs[i, j] &&cs[i-1, j])) return((1.+fs.x[i]) *(a[i] - a[i-1])+(1. - fs.x[i]) *(a[i | |
| j | a (2.*Delta) |
| return (a[i] - a[i-1])/Delta | |
| return (fs .x[i, j] > 0.5 &&fs .y[i, j+(j< 0)] &&fs .y[i-1, j+(j< 0)] &&cs[i, j] &&cs[i-1, j]) ?((1.+fs.x[i]) *((a[i | |
| *cs[i, 0, 0] a *[i -1, 0, 0] | cs (cs[i, 0, 0]+cs[i -1, 0, 0]+3.))+(1. - fs.x[i]) *((a[i |
| static double | embed_geometry (Point point, coord *p, coord *n) |
| static double | embed_area_center (Point point, double *x1, double *y1, double *z1) |
| This function and the macro below shift the position $(x1,y1,z1)$ to the position of the barycenter of the embedded fragment. | |
| double | embed_interpolate (Point point, scalar s, coord p) |
| This function returns the value of field s interpolated linearly at the barycenter p of the fragment of embedded boundary contained within the cell. | |
| trace int | fractions_cleanup (scalar c, vector s, double smin=0., bool opposite=false) |
| for (int _d=0;_d< 2;_d++) if(defined &&!fs.x[(n.x > 0.)]) defined | |
| if (defined) for(int l=0 | |
| if (fs.x[i+(i< 0), j] &&fs.y[i, j] &&fs.y[i, j+1] &&cs[i, j-1] &&cs[i, j] &&cs[i, j+1]) v[l] | |
| if (v[0]==nodata) | |
| if (v[1] !=nodata) return(d[1] *(bc - v[0])/d[0] - d[0] *(bc - v[1])/d[1])/((d[1] - d[0]) *Delta) | |
| return (bc - v[0])/(d[0] *Delta) | |
| double | dirichlet_gradient (Point point, scalar s, scalar cs, coord n, coord p, double bc, double *coef) |
| static coord | embed_gradient (Point point, vector u, coord p, coord n) |
| trace void | embed_force (scalar p, vector u, vector mu, coord *Fp, coord *Fmu) |
| The force exerted by the fluid on the solid can be written. | |
| double | embed_vorticity (Point point, vector u, coord p, coord n) |
| In two dimensions, embed_vorticity() returns the vorticity of velocity field u, on the surface of the embedded boundary contained in the cell. | |
| double | embed_flux (Point point, scalar s, vector mu, double *val) |
| macro2 double | dirichlet (double expr, Point point=point, scalar s=_s, bool *data=data) |
| For ease of use, we replace the Neumann and Dirichlet functions with macros so that they can be used either for standard domain boundaries or for embedded boundaries. | |
| macro2 double | dirichlet_homogeneous (double expr, Point point=point, scalar s=_s, bool *data=data) |
| macro2 double | neumann (double expr, Point point=point, scalar s=_s, bool *data=data) |
| macro2 double | neumann_homogeneous (double expr, Point point=point, scalar s=_s, bool *data=data) |
| trace void | update_tracer (scalar f, vector uf, vector flux, double dt) |
| void | event_metric (void) |
| Event: metric (i = 0) | |
| void | event_defaults (void) |
| We add the embedded boundary to the default display. | |
Variables | |
| scalar | cs [] |
| The volume and area fractions are stored in these fields. | |
| vector | fs [] |
| double(* | metric_embed_factor )(Point, coord) = NULL |
| scalar | a |
| scalar int | i |
| *cs[i, 0, 0] a *[i -1, 0, 0] | j |
| *cs[i, 0, 0] a *[i -1, 0, 0] *cs[i, j, 0] a *[i -1, j, 0] cs(cs[i, j, 0]+cs[i -1, j, 0]+3.)))/2. | attribute |
| The generalisation to 3D is a bit more complicated. | |
| scalar | s |
| scalar scalar coord | n |
| scalar scalar coord coord | p |
| scalar scalar coord coord double | bc |
| scalar scalar coord coord double double * | coef |
| For non-degenerate cases, the gradient is obtained using either second- or third-order estimates. | |
| double | d [2] |
| double | v [2] = {nodata,nodata} |
| bool | defined = true |
| l<=1;l++) { int i=(l+1) *sign(n.x);d[l]=(i - p.x)/n.x;double y1=p.y+d[l] *n.y;int j=y1 > | __pad0__ |
| y1 = j | |
| else | break |
| bid | embed |
Macro Definition Documentation
◆ BGHOSTS
| #define BGHOSTS 2 |
Embedded boundaries
Boundaries of general shape can be described using an integral (i.e. finite volume) formulation which takes into account the volume and area fractions of intersection of the embedded boundary with the Cartesian mesh.
We will need to deal with volume fractions. Interpolations (for Dirichlet boundary conditions) assume a 5x5 stencil.
◆ center_gradient
The centered gradient must not use values of fields entirely contained within the embedded boundary (for which cs is zero).
◆ cs_avg
When combining third-order Dirichlet conditions and approximate projections, instabilities may occur due to feedback between the pressure mode and the velocity, amplified by the third-order derivative.
This can be stabilised using the weighted average below when computing face velocities. The corresponding test case is [test/uf.c](). Note that if only second-order Dirichlet fluxes are used, simple averaging is stable.
◆ EMBED
◆ embed_pos
◆ face_condition
Face gradients and face values, computed from cell-centered values must be tuned to take into account the area fractions of the embedded boundary.
This follows the procedure described in Johansen and Colella, 1998, figure 3 and equation (16) in particular. Note that this is only used when using second-order fluxes.
◆ face_gradient_x
◆ face_gradient_y
◆ face_gradient_z
◆ face_value
◆ quadratic
| #define quadratic | ( | x, | |
| a1, | |||
| a2, | |||
| a3 | |||
| ) | (((a1)*((x) - 1.) + (a3)*((x) + 1.))*(x)/2. - (a2)*((x) - 1.)*((x) + 1.)) |
Dirichlet boundary condition
This function returns the gradient of scalar s, normal to the embedded boundary defined by cs, of unit normal vector n (normalised using the Euclidean norm, not the box norm) and of centroid p. The Dirichlet boundary condition bc is imposed on the embedded boundary.
The calculation follows Johansen and Colella, 1998 and is summarised in the figure below (see also Figure 4 of Johansen and Colella and Figure 2 of Schwartz et al, 2006 for the 3D implementation).
For degenerate cases, a non-zero value of coef is returned and coef*s[] must be added to the value returned to obtain the gradient.
◆ SEPS
Function Documentation
◆ a()
| j a | ( | 2.* | Delta | ) |
◆ assert()
| assert | ( | cs && | cs[i][i-1] | ) |
◆ cs()
◆ dirichlet()
For ease of use, we replace the Neumann and Dirichlet functions with macros so that they can be used either for standard domain boundaries or for embedded boundaries.
The distinction between the two cases is based on whether the dirichlet parameter is passed to the boundary function (using the data parameter).
Definition at line 717 of file embed.h.
References data, embed_area_center(), point, s, x, y, and z.
Referenced by embed_flux(), embed_gradient(), and event_metric().
◆ dirichlet_gradient()
◆ dirichlet_homogeneous()
◆ embed_area_center()
This function and the macro below shift the position $(x1,y1,z1)$ to the position of the barycenter of the embedded fragment.
Definition at line 239 of file embed.h.
References area(), cs, embed_geometry(), n, p, point, x, and y1.
Referenced by dirichlet(), and neumann().
◆ embed_flux()
Flux through the embedded boundary
This function computes the flux through the embedded boundary contained within a cell
\[ \int_b \mu \nabla s\cdot\mathbf{n} db \]
with \(db\) the elementary boundary surface and \(\mathbf{n}\) the embedded boundary (outward-pointing) normal.
Boundary conditions for s are taken into account.
The result is returned in val.
For degenerate cases, the value returned by the function must be multiplied by s[] and added to val.
If the cell does not contain a fragment of embedded boundary, the flux is zero.
If the boundary condition is homogeneous Neumann, the flux is zero.
We compute the normal, area and barycenter of the fragment of embedded boundary contained within the cell.
If the boundary condition is Dirichlet, we need to compute the normal gradient.
We retrieve the (average) value of \(\mu\) without the metric.
Definition at line 657 of file embed.h.
References alpha, area(), coef, cs, dimension, dirichlet(), dirichlet_gradient(), embed, facet_normal(), fm, fs, metric_embed_factor, mu, n, normalize(), p, plane_alpha, plane_area_center, point, s, SEPS, val(), vector::x, and x.
Referenced by relax_diffusion(), residual_diffusion(), and viscosity().
◆ embed_force()
The force exerted by the fluid on the solid can be written.
\[ \mathbf{F}_{\Gamma} = - \int_{\partial \Gamma} ( - p\mathbf{I} + 2 \mu \mathbf{D}) \cdot \mathbf{n}d \partial \Gamma \]
with \(\Gamma\) the solid boundary. It can be further decomposed into a pressure (i.e. "form") drag
\[ \mathbf{F}_p = \int_{\partial \Gamma} p \mathbf{n}d \partial \Gamma \]
and a viscous drag
\[ \mathbf{F}_{\mu} = - \int_{\partial \Gamma} 2 \mu \mathbf{D} \cdot \mathbf{n}d \partial \Gamma \]
These two vectors are computed by the embed_force() function.
To compute the pressure force, we first get the coordinates of the barycentre of the embedded fragment, its area and normal, and then interpolate the pressure field on the surface.
To compute the viscous force, we first need to retrieve the local value of the viscosity (ideally at the barycentre of the embedded fragment). This is not completely trivial since it is defined on the faces of the cell. We use a surface-fraction-weighted average value.
To compute the viscous force, we need to take into account the (Dirichlet) boundary conditions for the velocity on the surface. We only know how to do this when computing the normal gradient \(\mathbf{\nabla}\mathbf{u}\cdot\mathbf{n}\) using the embed_gradient() function. We thus need to re-express the viscous force using only normal derivatives of the velocity field.
If we assume that \(\mathbf{u}\) is constant on the boundary, then
\[ \mathbf{{\nabla}} \mathbf{u} \cdot \mathbf{t}= \mathbf{0} \]
with \(\mathbf{t}\) the unit tangent vector to the boundary. We thus have the relations
\[ \mathbf{{\nabla}} \mathbf{u} = \left( \mathbf{{\nabla}} \mathbf{u} \cdot \mathbf{n} \right) \mathbf{n} + \left( \mathbf{{\nabla}} \mathbf{u} \cdot \mathbf{t} \right) \mathbf{t} = \left( \mathbf{{\nabla}} \mathbf{u} \cdot \mathbf{n} \right) \mathbf{n} \]
\[ \mathbf{D}= \frac{1}{2} \left( \mathbf{{\nabla}} \mathbf{u} + \mathbf{{\nabla}}^T \mathbf{u} \right) = \frac{1}{2} \left(\begin{array}{cc} 2 \left( \mathbf{{\nabla}} u \cdot \mathbf{n} \right) n_x & \left( \mathbf{{\nabla}} u \cdot \mathbf{n} \right) n_y + \left( \mathbf{{\nabla}} v \cdot \mathbf{n} \right) n_x\\ \left( \mathbf{{\nabla}} u \cdot \mathbf{n} \right) n_y + \left( \mathbf{{\nabla}} v \cdot \mathbf{n} \right) n_x & 2 \left( \mathbf{{\nabla}} v \cdot \mathbf{n} \right) n_y \end{array}\right) \]
\[ \mathbf{F}_{\mu} = - \int_{\Gamma} \left(\begin{array}{c} \left[2 \mu \left( \mathbf{{\nabla}} u \cdot \mathbf{n} \right) n_x \right] n_x + \mu \left[ \left( \mathbf{{\nabla}} u \cdot \mathbf{n} \right) n_y + \left( \mathbf{{\nabla}} v \cdot \mathbf{n} \right) n_x \right] n_y\\ \left[2 \mu \left( \mathbf{{\nabla}} v \cdot \mathbf{n} \right) n_y \right] n_y + \mu \left[ \left( \mathbf{{\nabla}} u \cdot \mathbf{n} \right) n_y + \left( \mathbf{{\nabla}} v \cdot \mathbf{n} \right) n_x \right] n_x \end{array}\right) \]
\[ \mathbf{F}_{\mu} = - \int_{\Gamma} \left(\begin{array}{c} \mu \left[ \left( \mathbf{{\nabla}} u \cdot \mathbf{n} \right) (n^2_x + 1) + \left( \mathbf{{\nabla}} v \cdot \mathbf{n} \right) n_x n_y \right]\\ \mu \left[ \left( \mathbf{{\nabla}} v \cdot \mathbf{n} \right) (n^2_y + 1) + \left( \mathbf{{\nabla}} u \cdot \mathbf{n} \right) n_x n_y \right] \end{array}\right) \]
Definition at line 511 of file embed.h.
References area(), assert, b, cs, dimension, embed_geometry(), embed_gradient(), embed_interpolate(), fm, mu, n, p, point, pow(), sq(), u, vector::x, and x.
◆ embed_geometry()
Utility functions for the geometry of embedded boundaries
For a cell containing a fragment of embedded boundary (i.e. for which \(0 < cs < 1\)), embed_geometry() returns the area of the fragment, the relative position p of the barycenter of the fragment and the boundary normal n.
Definition at line 225 of file embed.h.
References alpha, area(), cs, facet_normal(), fs, n, normalize(), p, plane_alpha, plane_area_center, and point.
Referenced by embed_area_center(), and embed_force().
◆ embed_gradient()
Surface force and vorticity
We first define a function which computes \(\mathbf{\nabla}\mathbf{u}\cdot\mathbf{n}\) while taking the boundary conditions on the embedded surface into account.
Definition at line 473 of file embed.h.
References cs, dimension, dirichlet(), dirichlet_gradient(), embed, n, nodata, p, point, u, val(), x, and coord::x.
Referenced by embed_force(), and embed_vorticity().
◆ embed_interpolate()
This function returns the value of field s interpolated linearly at the barycenter p of the fragment of embedded boundary contained within the cell.
Definition at line 257 of file embed.h.
References assert, cs, dimension, i, j, p, s, sign(), val(), and x.
Referenced by embed_force().
◆ embed_vorticity()
In two dimensions, embed_vorticity() returns the vorticity of velocity field u, on the surface of the embedded boundary contained in the cell.
p is the relative position of the barycentre of the embedded fragment and n its normal.
We compute \(\mathbf{{\nabla}}\mathbf{u}\cdot\mathbf{n}\), taking the boundary conditions into account.
The vorticity is then obtained using the relations
\[ \omega = \partial_x v - \partial_y u = \left( \mathbf{{\nabla}} v \cdot \mathbf{n} \right) n_x - \left( \mathbf{{\nabla}} u \cdot \mathbf{n} \right) n_y \]
Definition at line 618 of file embed.h.
References embed_gradient(), n, p, point, u, and x.
◆ event_defaults()
We add the embedded boundary to the default display.
Event: defaults (i = 0)
Event: defaults (i = 0 )
The default density field is set to unity (times the metric).
We reset the multigrid parameters to their default values.
If the viscosity is non-zero, we need to allocate the face-centered viscosity field.
We also initialize the list of tracers to be advected with the VOF function \(f\) (or its complementary function).
We set limiting.
On trees, we ensure that limiting is also applied to prolongation and refinement.
We add the interface and the density to the default display.
We switch to a pure minmod limiter by default for increased robustness.
With the MUSCL scheme we use the CFL depends on the dimension of the problem.
On trees we need to replace the default bilinear refinement/prolongation with linear so that reconstructed values also use slope limiting.
The restriction/refine attributes of the charge density are those of a tracer otherwise the conservation is not guaranteed.
By default the permittivity is unity and other quantities are zero.
Definition at line 953 of file embed.h.
References display().
◆ event_metric()
Event: metric (i = 0)
Default settings
To apply the volume/area fraction-weighting to the solvers, we define the embedded solid using the embedded fractions. The fields are no longer constant and must be allocated.
The cm and fm fields contain the product of the metric and solid factors. For a Cartesian coordinate system cm and fm are thus identical to the solid factor fields cs and fs.
For prolongation we cannot use the same function since the surface fraction field fs is not necessarily defined for prolongation cells. So we switch back to the default fraction refinement (which is less accurate but only relies on cs).
Note that we do not need to change the refine method since the default refine method calls the prolongation method for each component.
Definition at line 909 of file embed.h.
References _i, assert, cm, cs, dimension, embed_fraction_refine(), fm, fraction_refine(), fs, restriction, vector::x, and x.
◆ for() [1/2]
| for | ( | ) |
Definition at line 279 of file cartesian.h.
References list_add(), periodic_bc(), right, s, and x.
◆ for() [2/2]
| for | ( | ) |
◆ fractions_cleanup()
Since both surface and volume fractions are altered, iterations are needed. This reflects the fact that changes are coupled spatially through the topology of the domain: for examples, long, unresolved "filaments" may need many iterations to be fully removed.
Face fractions of empty cells must be zero.
If opposite surface fractions are zero (and volume fraction is non-zero), then we are dealing with a thin "tube", which we just remove because it can sometimes lead to non-convergence when projecting the velocity field.
The number of "non-empty" faces (i.e. faces which have a surface fraction larger than epsilon) cannot be smaller than the dimension (the limiting cases correspond to a triangle in 2D and a tetrahedron in 3D).
Definition at line 295 of file embed.h.
References _i, c, dimension, i, LINENO, n, s, and x.
Referenced by event_adapt().
◆ if() [1/5]
◆ if() [2/5]
|
pure virtual |
◆ if() [3/5]
◆ if() [4/5]
◆ if() [5/5]
◆ neumann()
◆ neumann_homogeneous()
◆ return() [1/3]
| return | ( | a - | a[i][i-1] | ) |
◆ return() [2/3]
| return | ( | bc - | v[0] | ) |
◆ return() [3/3]
◆ update_tracer()
Prolongation for the multigrid solver
We use a simplified prolongation operator for the multigrid solver i.e. simple injection if bilinear interpolation would use values which are fully contained within the embedded boundary.
Lifting the "small cell" CFL restriction
For explicit advection schemes, the timestep is limited by the CFL conditions
\[ \Delta t < \frac{c_s\Delta}{f_i|u_i|} \]
where \(i\) is the index of each face, and \(c_s\) and \(f_i\) are the embedded volume and face fractions respectively. It is clear that the timestep may need to be arbitrarily small if \(c_s/f_s\) tends toward zero. This is the "small cell" restriction of cut-cell finite-volume techniques.
A classical technique to avoid this limitation is to use a "cell merging" procedure, where the fluxes from cells which would "overflow" are redistributed to neighboring cells.
The function below uses this approach to update a field f, advected by the face velocity field uf, with corresponding advection fluxes flux*, during timestep dt which only verifies the standard CFL condition
\[ \Delta t < \frac{\Delta}{|u_i|} \]
Note that the distinction should be made between \(c_m\), the cell fraction metric, and \(c_s\), the embedded fraction. This is not done now so that embedded boundaries cannot be combined with a metric yet.
The field e will store the "overflowing" sum of fluxes for each cell.
If the cell is empty, it cannot overflow.
If the cell does not contain an embedded boundary, it cannot overflow either and the sum of the fluxes can be added to advance f* in time.
If the cell contains the embedded boundary, we compute the maximum timestep verifying the restrictive CFL condition
\[ \Delta t_{max} = \frac{c_s\Delta}{max(f_i|u_i|)} \]
Note that fs does not appear in the code below because uf already stores the product \(u_f \, f_m\).
We compute the sum of the fluxes.
If the timestep is smaller than \(\Delta t_{max}\), the cell cannot overflow and f is advanced in time using the entire flux.
Otherwise, the cell is filled "to the brim" by advancing f using the maximum allowable timestep. The field e is used to store the excess flux, weighted by the sum of the neighboring embedded fractions.
In a second phase, the excesses in each cell are added to the neighboring cells in proportion of their embedded fractions.
Definition at line 803 of file embed.h.
References _i, cm, cs, dimension, dt, dtmax, f, flux, i, SEPS, sq(), uf, vector::x, and x.
Referenced by advection().
Variable Documentation
◆ __pad0__
◆ a
◆ attribute
| *cs[i, 0, 0] a *[i -1, 0, 0] * cs [ i , j , 0 ] a* [ i -1, j , 0 ] cs (cs[ i , j , 0 ] + cs[ i -1, j , 0 ] + 3.)))/2. attribute |
The generalisation to 3D is a bit more complicated.
See Fig. 1 of Schwartz et al, 2006. We use the functions above to redefine the face gradient macros. Note that the second-order face gradients and averaging are used only if the corresponding scalar attribute below (third because of third-order accuracy when using Dirichlet conditions, see [test/neumann.c]) is set to true. The default is false.
◆ bc
Definition at line 378 of file embed.h.
Referenced by dirichlet_gradient(), event_pressure(), if(), turbulence_epsilon_bc(), turbulence_k_bc(), turbulence_psi_bc(), turbulence_q2l_bc(), and turbulence_q2over2_bc().
◆ break
◆ coef
| * coef |
For non-degenerate cases, the gradient is obtained using either second- or third-order estimates.
Definition at line 379 of file embed.h.
Referenced by colormap_color(), dirichlet_gradient(), embed_flux(), and if().
◆ cs
The volume and area fractions are stored in these fields.
Definition at line 21 of file embed.h.
Referenced by dirichlet_gradient(), embed_area_center(), embed_flux(), embed_force(), embed_fraction_refine(), embed_geometry(), embed_gradient(), embed_interpolate(), event_adapt(), event_defaults(), event_metric(), for(), for(), half_column(), if(), refine_cm_axi(), refine_embed_linear(), refine_face_x_axi(), restriction_embed_linear(), solid(), and update_tracer().
◆ d
| double d[2] |
Definition at line 383 of file embed.h.
Referenced by box_boundary_level(), box_boundary_level(), box_boundary_level(), box_boundary_level_normal(), box_boundary_level_normal(), box_boundary_level_tangent(), box_matrix(), cartesian_init_face_vector(), cartesian_init_vector(), cartesian_init_vertex_scalar(), check_stencil(), coarsen_distance(), delete_distance(), display_control_internal(), display_control_json(), display_control_lookup(), display_control_update(), display_destroy(), distance(), distance_curvature(), dtheta(), eigenvalues(), eigsrt(), event_acceleration(), event_init(), event_stability(), event_viscous_term(), foreach_boundary_dir(), foreach_cell_restore(), h_relax(), if(), init_grid(), input0(), kpp_wscale(), list_add_depend(), list_add_depends(), matrix(), matrix1(), momentum(), okada(), okada_rectangular_source(), parabola_fit_init(), periodic_boundary(), pmfunc_alloc(), pmfunc_free(), pstrdup(), quad_neighbor(), quad_neighbor_finest(), refine_distance(), refine_face_solenoidal(), relax(), relax_diffusion(), relax_hydro(), relax_nh(), relax_nh(), relax_nh1(), remove_droplets(), residual_diffusion(), residual_nh(), residual_nh3(), residual_viscosity(), scalar_is_dirty(), stencil_val(), stencil_val_a(), update_distance(), update_green_naghdi(), vof_advection(), and write_stencil_index().
◆ defined
◆ embed
| bid embed |
Definition at line 463 of file embed.h.
Referenced by embed_flux(), embed_gradient(), and viscosity().
◆ fs
| vector fs[] |
Definition at line 22 of file embed.h.
Referenced by embed_flux(), embed_fraction_refine(), embed_geometry(), event_adapt(), event_metric(), fine(), for(), gpu_reduction(), gradients(), if(), if(), if(), loadNormalShader(), prediction(), refine_embed_linear(), refine_face_x_axi(), refine_face_y_axi(), solid(), and update_conservation().
◆ i
Definition at line 73 of file embed.h.
Referenced by _box_json(), _cells_json(), _draw_string_json(), _draw_vof_json(), _isoline_json(), _isosurface_json(), _labels_json(), _lines_json(), _squares_json(), _travelling_json(), _vectors_json(), _view_json(), adapt_wavelet(), add_boundary(), advance_generic(), advect(), alloc_children(), append_pid(), apply_bc(), area_integral(), args(), array_remove(), assemble_node(), barycenter(), bc_grd(), blue_white_red(), boundary_internal(), boundary_stencil(), bubbles_are_close(), bview_interface_json(), cartesian_scalar_clone(), cell(), check_depth(), check_flags(), check_snd_rcv_matrix(), check_stencil(), check_two_one(), colorized(), colormap_color(), cool_warm(), cpu_reduction(), curvature_prolongation(), de(), debug_mpi(), delete(), delete_terrain(), diagonalization_2D(), display_control_json(), display_control_lookup(), display_destroy(), display_send(), display_update(), dphidt(), eigenvalues(), eigsrt(), embed_interpolate(), evaluate_expression(), event__progress(), event_acceleration(), event_cleanup(), event_cond(), event_defaults(), event_face_fields(), event_perfs(), event_refresh_display(), event_viscous_term(), event_vof(), facets(), fclone(), find_coreGL(), flux(), for(), foreach_cell_post_root(), foreach_stencil(), foreach_stencil_generic(), fractions_cleanup(), free_boundaries(), free_solver(), GetRoot(), getvalue(), gpu_errors_scan_bytes(), gpu_reduction(), gray(), height_curvature_fit(), if(), if(), inc_scan_bytes(), includes(), independents(), init_const_scalar(), init_event(), init_grid(), init_solver(), input_pgm(), input_stl(), interfacial(), interpolate_array(), interpolate_linear(), jet(), kdt_heap_split(), kdt_write(), lambda2(), list_clone(), list_prepend(), list_print(), load(), lookup_tag(), main(), mapped_position(), matrix_new(), maxruntime(), mem_allocated(), mem_allocated(), mem_assign(), mem_assign(), mem_destroy(), mem_free(), mem_free1d(), mempool_alloc(), mempool_free(), memrange_alloc(), memrange_free(), mg_cycle(), mpi_boundary_refine(), mpi_boundary_update_buffers(), mpi_partitioning(), msolve(), new_const_scalar(), new_const_vector(), next_string(), no_coalescence(), normal_neighbor(), ohmic_flux(), OMP_PARALLEL(), open_image_cleanup(), open_image_lookup(), openpath(), output_fluxes(), output_vtk(), parabola_fit_add(), parabola_fit_init(), parabola_fit_solve(), parse_params(), periodic_boundary_level_x(), periodic_function(), pmfunc_index(), pmfuncs_free(), pmuntrace(), post_scan_bytes(), prediction(), prolongation_vertex(), psort(), push_once(), py_action(), py_inc(), py_start(), qpclose(), qpclose_all(), qpopen(), quad_neighbor(), quad_neighbor_finest(), quad_x(), quad_y(), query(), query_sum(), randomap(), rcv_destroy(), rcv_pid_append_pids(), rcv_pid_destroy(), rcv_pid_pointer(), rcv_pid_print(), rcv_pid_receive(), rcv_pid_row(), rcv_pid_send(), rcv_pid_wait(), rcv_pid_write(), realloc_scalar(), refine_embed_linear(), refine_face_solenoidal(), remap_c(), remap_robin(), remove_droplets(), repeat(), reset(), restriction_embed_linear(), restriction_vertex(), riemann(), right_value(), RPE(), segment_flux(), smatrix_inverse(), solve(), solve_hessenberg(), stencil_val(), stencil_val_a(), tag(), terrain(), timer_print(), timer_timing(), tracer_fluxes(), tracer_is_close(), tree_boundary_level(), treex(), update_cache_f(), update_conservation(), update_distance(), update_sum(), update_tracer(), vertex_buffer_glBegin(), vertex_buffer_glEnd(), vertex_buffer_push_index(), vertical_remapping(), volumez(), ws_send_array(), yy_get_next_buffer(), yy_get_next_buffer(), yy_get_next_buffer(), z_indexing(), zarea(), and zvolume().
◆ j
| def false def true def S_LINENO def S_LINENO define _k define _k define _k define _k define _k define _k define _k define k define k define k define j |
Definition at line 88 of file embed.h.
Referenced by alloc_children(), apply_bc(), array_remove(), bc_grd(), box_boundary_level(), bubbles_are_close(), cell(), check_depth(), check_snd_rcv_matrix(), check_two_one(), colorized(), colormap_color(), cool_warm(), curvature_prolongation(), de(), dphidt(), eigenvalues(), eigsrt(), embed_interpolate(), fine(), for(), foreach_cell_post_root(), getvalue(), gpu_reduction(), half_column(), height_curvature_fit(), heights(), if(), if(), if(), if(), independents(), init_event(), init_grid(), input_pgm(), input_stl(), interpolate_array(), interpolate_linear(), lambda2(), mapped_position(), maxruntime(), mem_allocated(), mem_allocated(), mem_assign(), mem_destroy(), mem_free(), mem_free1d(), msolve(), no_coalescence(), OMP_PARALLEL(), output_vtk(), parabola_fit_add(), parabola_fit_init(), parabola_fit_solve(), periodic_function(), prepend_path(), prolongation_vertex(), quad_neighbor(), quad_neighbor_finest(), rcv_append(), rcv_pid_append_pids(), rcv_pid_send(), refine_embed_linear(), refine_face_solenoidal(), remap_robin(), restriction_embed_linear(), restriction_vertex(), right_value(), smatrix_inverse(), stencil_val(), stencil_val_a(), tag(), tracer_is_close(), update_cache_f(), update_distance(), vertex_buffer_glEnd(), and zareaval().
◆ metric_embed_factor
Definition at line 24 of file embed.h.
Referenced by embed_flux(), and event_metric().
◆ n
Definition at line 378 of file embed.h.
Referenced by dirichlet_gradient(), embed_area_center(), embed_flux(), embed_force(), embed_geometry(), embed_gradient(), embed_vorticity(), fractions_cleanup(), and if().
◆ p
Definition at line 378 of file embed.h.
Referenced by dirichlet_gradient(), embed_area_center(), embed_flux(), embed_force(), embed_geometry(), embed_gradient(), embed_interpolate(), embed_vorticity(), and if().
◆ s
| scalar s |
Definition at line 377 of file embed.h.
Referenced by dirichlet(), dirichlet_gradient(), dirichlet_homogeneous(), embed_flux(), embed_interpolate(), fractions_cleanup(), neumann(), and neumann_homogeneous().
◆ v
Definition at line 383 of file embed.h.
Referenced by apply_bc(), bc_grd(), boundary_flux(), box_boundary_level(), cartesian_debug(), cartesian_init_face_vector(), cartesian_init_vector(), check_stencil(), default_stencil(), eigenvalues(), eigsrt(), face_average(), glvertex_normal3d(), gradients(), if(), if(), if(), if(), if(), init_const_vector(), init_grid(), input_pgm(), interpolate(), interpolate_array(), interpolate_linear(), kpp_bottom_layer(), kpp_do_kpp(), kpp_surface_layer(), line_area(), mempool_alloc(), mempool_free(), mg_solve(), multigrid_debug(), multigrid_init_face_vector(), multigrid_init_vector(), multigrid_setup_vector(), new_bid(), new_const_vector(), normal_neighbor(), normf(), output_gauges(), periodic_boundary(), planeBoxOverlap(), rcv_pid_send(), refine_elevation(), refine_face(), refine_face_solenoidal(), refine_injection(), refine_reset(), remap_c(), remap_central(), reset(), restriction_elevation(), right_value(), run(), solve_hessenberg(), tensors_from_vectors(), tree_boundary_level(), tree_init_face_vector(), tree_init_vector(), tree_setup_vector(), update_conservation(), update_distance(), vectors_add(), vectors_append(), vectors_copy(), vectors_from_scalars(), vectors_lenb(), vertex_buffer_glVertex2d(), vertex_buffer_glVertex3d(), and vertical_remapping().
◆ y1
| y1 = j |
Definition at line 394 of file embed.h.
Referenced by DistancePointEllipse(), embed_area_center(), okada(), and parabola_fit_add().
