multiPhysicsFoam – Utility

Docs: calcCurvature

Mon, 01 Jan 0001 00:00:00 +0000

Overview

calcCurvature is a standalone application that builds the finite-area mesh (faMesh) of a case and evaluates the mean curvature of that surface for a single time. It writes two volume fields, curvature and curvatureNew. Both are zero everywhere except on the boundary patch named freeSurface or interface. The curvature it computes is the same faMesh::faceCurvatures() that capillaryInterface uses for the surface-tension pressure jump. Use it to check the curvature quality of a surface mesh (e.g. a spherical bubble, where $\kappa$ should be uniform) before running a capillary case. It is a single-mesh tool: it does not read multiRegionProperties and knows nothing about regions beyond the standard -region option.

Method

Time and mesh. The time is selected with the standard time options (see Usage). The run time is set to the first selected time, and only that time is processed. The mesh is created as a dynamicFvMesh (region from -region, default region0). If constant/[<region>/]dynamicMeshDict is absent, a staticFvMesh is used. The mesh is never moved.
Finite-area mesh. faMesh(mesh) is constructed for the default area name, i.e. it reads the faMesh written by makeFaMesh (constant/[<region>/]faMesh).
Patch detection. The boundary is scanned for a patch named freeSurface or interface. If both exist, the one with the higher patch index wins. If neither exists, the application aborts with a bare FatalError (no message).
Curvature (curvature). The faMesh face curvature is copied into the detected patch:
$$ \mathbf{k}_N = \frac{1}{S_f}\sum_{e \in f} \mathbf{L}_e\, c_e, \qquad \kappa = \operatorname{sign}\!\left(\mathbf{k}_N\cdot\mathbf{n}_f\right)\,|\mathbf{k}_N| $$
with $S_f$ the face area, $\mathbf{L}_e$ the edge length vectors (Le()), $c_e$ the edge length correction (edgeLengthCorrection(), $c_e = \cos\!\big(\tfrac{1}{2}\arcsin|\mathbf{n}_a\times\mathbf{n}_b|\big)$ from the two edge point normals) and $\mathbf{n}_f$ the faMesh face area normal. $\kappa$ is therefore signed relative to the faMesh normal.
Alternative curvature (curvatureNew). The same edge sum $\mathbf{k}_N$ is computed again. A unit “normal” is built from it, $\hat{\mathbf{n}} = \mathbf{k}_N/|\mathbf{k}_N|$, falling back to the fvPatch face normal where $|S_f\,\mathbf{k}_N| \le$ SMALL. The written value is
$$ \kappa_\text{new} = \hat{\mathbf{n}}\cdot\mathbf{k}_N $$
Because $\hat{\mathbf{n}}$ is parallel to $\mathbf{k}_N$, this is $|\mathbf{k}_N| = |\kappa|$ wherever the fallback is not active, i.e. the unsigned curvature.
Report. Min/max and arithmetic mean (unweighted by face area) of both patch fields are printed to the log.

Usage

Command line (standalone application):

calcCurvature [-region <name>] [-time <ranges> | -latestTime] [-constant] [-noZero]

Option	Description
`-region <name>`	Mesh region to operate on. Default: `region0` (case root).
`-time <ranges>`	Time ranges to select (e.g. `0.1`, `:10,20 40:70`). Only the first selected time is processed.
`-latestTime`	Select the latest time. On its own, this processes the latest time; combined with other selections only the earliest one is processed.
`-constant`	Include `constant/` in the time list.
`-noZero`	Exclude `0/` from the time list.

Without time options all time directories (including 0/) are selected, so the earliest time is processed. If no time directory matches, constant/ is used with a warning.

Typical sequence for a single-mesh case:

blockMesh
makeFaMesh
calcCurvature

Input / Output

Read

File	Description
`constant/[<region>/]polyMesh`	Volume mesh; must contain a patch named `freeSurface` or `interface`
`constant/[<region>/]faMesh`	Finite-area mesh from `makeFaMesh` on that patch
`constant/[<region>/]dynamicMeshDict`	Optional; selects the `dynamicFvMesh` type (static if absent)
`system/[<region>/]faSchemes`, `faSolution`	Required by the `faMesh`
`system/[<region>/]fvSchemes`, `fvSolution`	Required by the `fvMesh`

Written to <time>/[<region>/] of the processed time:

Field	Type	Unit	Content
`curvature`	`volScalarField`	1/m	0 in all cells and on all other patches; signed $\kappa$ on the free-surface/interface patch
`curvatureNew`	`volScalarField`	1/m	0 in all cells and on all other patches; $\kappa_\text{new}$ (unsigned, see Method) on that patch

All patches are of type calculated. No other fields are read or written.

Known Limitations

Single time only. The selected time list is not looped over. Only the earliest selected time is processed, even if -time selects several.
Fixed patch names. The patch must be called exactly freeSurface or interface. There is no option to pick another name (e.g. interfaceShadow). A missing patch aborts with an empty error message.
faMesh must cover exactly that patch. The faMesh face values are assigned directly to the patch, so the faMesh must be built on that patch only, with the same face count and ordering. A faMesh on a different or additional patch causes a size mismatch.
curvatureNew is unsigned. Its “normal” is derived from the edge sum itself rather than from the surface normal, so it carries no sign. It is not the signed normal force density that its comments suggest.
Mean of face values. The printed average is an unweighted face average, not an area-weighted one.
Libraries for the dynamicMeshDict. The application links only finiteVolume, finiteArea, dynamicFvMesh, dynamicMesh and meshTools. A dynamicMeshDict that selects a mesh type or motion solver from another library (e.g. interfaceTrackingFvMesh, or a motion solver from fvMotionSolvers) needs that library loaded through the dictionary’s library entries. Otherwise the selection fails.
No parallel-specific handling. Min/max/average are evaluated per processor without reduction.

Tutorials

Tutorial	Description
`tutorials/multiphaseFlow/3dDuineveldRisingBubble/baseMeshes/meshA`	Base bubble mesh generation (`blockMesh`, `makeFaMesh` on patch `interface`). The `calcCurvature` call is present but commented out in `Allrun`.
`tutorials/multiphaseFlow/3dDuineveldRisingBubble/hexBaseMeshes/meshA`	Same for the hex base mesh; the call is likewise commented out.

Docs: solidPointDisplacement

Mon, 01 Jan 0001 00:00:00 +0000

Overview

solidPointDisplacement is a function object (library libmultiRegionFOs) that monitors the displacement of one point of a solid region. At start-up it picks the mesh point closest to a user-given location. At every execution it writes the time, the three components and the magnitude of the point displacement field pointD at that point to a .dat file. pointD is provided by the solidStVK region type. The typical use is the tip displacement of an elastic structure in FSI benchmarks such as Hron-Turek FSI3.

Method

Region. The region keyword names the solid mesh. If it is omitted, solid is used when a mesh of that name exists, otherwise region0.
Point selection (constructor, once). The vector point is read. On each processor the mesh point with the smallest distance $|\mathbf{x}_i - \mathbf{x}_\text{probe}|$ is found by a brute-force search over all points of the reference (undeformed) mesh. Only the processor(s) holding the global minimum distance keep their point. If several processors tie (e.g. a point on a processor boundary), the one with the highest processor number is kept. Each processor that keeps a point prints its distance to the given location. If no processor ends up with a point, the run aborts.

Note: this search always uses the mesh solid if it exists, otherwise region0, regardless of the region keyword (see Known Limitations).
Sampling (execute(), once per time step by default). In mesh region, the pointVectorField pointD is looked up. Its value at the chosen point is taken without interpolation. All other processors contribute zero, and the values are summed over processors. The master writes one line
$$ t \quad D_x \quad D_y \quad D_z \quad |\mathbf{D}| $$
If pointD does not exist in that mesh, a message pointVectorField pointD not found is printed and nothing is written for that step.

write() does nothing and read() ignores the dictionary, so changes to the entry during the run (runTimeModifiable) have no effect.

Usage

system/controlDict entry (function object):

functions
{
 displacement
 {
 type solidPointDisplacement;
 libs (multiRegionFOs);
 region solid;
 point (0.6 0.2 0.0075);
 }
}

Keyword	Description	Required	Default
`type`	`solidPointDisplacement`	yes	—
`libs`	`(multiRegionFOs)`	yes	—
`point`	Location (m); the closest solid mesh point is monitored	yes	—
`region`	Name of the solid mesh that holds `pointD`	no	`solid` if that mesh exists, else `region0`

The standard function object controls that OpenFOAM handles outside the object itself (e.g. executeControl, executeInterval, timeStart, timeEnd) can be added. The object itself reads no other keywords.

Input / Output

Read

Field	Type	Mesh	Description
`pointD`	`pointVectorField`	`region`	Point displacement (m); registered by `solidStVK`

Written (master processor only):

<case>/postProcessing/<startTime>/solidPointDisplacement_<name>.dat

<name> is the function object entry name (e.g. displacement) and <startTime> is the case start time. In parallel runs the file is still written to the undecomposed case directory (processor*/../postProcessing). The file starts with the header # Time Dx Dy Dz magD, followed by one space-separated line per execution. The file is opened anew at start-up, so a restart from the same start time overwrites the earlier file.

Known Limitations

region is only partly honoured. The closest-point search always uses mesh solid (or region0 if there is no solid mesh). The sampling uses region. In practice the solid region must be called solid. With another name the search falls back to region0, which does not exist in a multi-region case, and the run aborts.
Nearest mesh point, no interpolation. The monitored location is the closest existing mesh point, not the exact point. The distance is printed at start-up, so check it in the log.
Requires pointD. Only region types that register a pointVectorField called pointD (currently solidStVK) can be monitored. Other fields cannot be selected.
Reference configuration. The point is selected on the solid mesh points at start-up. This is correct for the total-Lagrangian solidStVK, whose mesh never moves.
Brute-force search. The point search is $O(N_\text{points})$ per processor. This is negligible since it runs only once.
Distributed cases. With distributed data (no shared case directory), writing to processor*/../postProcessing can fail.
Header comment. The class description in the header refers to “temperature” and least-squares vol-to-point interpolation. Both are wrong: the object reads pointD directly.

Tutorials

Tutorial	Description
`tutorials/fluidStructureInteraction/HronTurekFsi3`	Beam tip displacement at `(0.6 0.2 0.0075)` (entry `displacement` in `system/functions`, included from `controlDict`); plotted by `deflection.gnuplot` from `postProcessing/0/solidPointDisplacement_displacement.dat`
`tutorials/fluidStructureInteraction/beamInCrossFlow`	Ships a `deflection.gnuplot` that reads the same file, but its `controlDict` defines no `solidPointDisplacement` entry, so the file is not produced