Notched Specimens

Machined notches are a common substitute for natural defects in ultrasonic NDT qualification work: their geometry is well controlled and they produce strong, repeatable scattered signals. This tutorial compares the ultrasonic wavefields observed between three different surface-breaking notch geometries that are available in W-Scan, namely:

• Rectangular: a flat-bottomed slot of fixed width and depth, used as the canonical reference reflector in many NDT reference blocks.
• Stepped: three nested rectangles of decreasing width and increasing depth, which approximates a stepped V-shaped profile.
• Crack: a thin, jagged surface-breaking crack constructed from a randomly perturbed centreline, used to mimic a real fatigue crack.

For each geometry, a wedge probe is placed on the surface of a steel specimen and a tone-burst excitation is injected into the medium. The volumetric wavefield between each geometric entity is compared side-by-side in order to better understand how these different geometries impact the resulting wave propagation.

Importing libraries and setting constants

As usual, a series of standardized libraries are imported.

For convenience, a number of constants are defined below. Constant parameters are denoted with variable names in all capital letters.

First, the simulation site and the location to which the project should be saved are defined.

Next, parameters that control the mesh resolution and the source time function are set.

The material properties of the various constituents can be defined using sn.material.Material objects. These can either be defined manually or with W-Scan’s material library.

Finally, the geometric properties of the domain can be defined. This includes the overall extents of the steel plate and the nominal dimensions that will be reused across all three notch geometries so that they can be fairly compared. By convention, the top of the specimen sits at y = 0 and the specimen extends downwards into the negative y half-plane; the notch is then introduced from the bottom surface and extends upwards (the Specimen class internally rotates the supplied notch by 180 degrees).

Notch geometry examples

Each notch is constructed as a wscan.geometry.dim2.notches.Specimen, which combines a rectangular plate with an embedded Notch. Three different notch types are instantiated below, each sharing the same specimen extents but differing in the morphology of the reflector itself.

Rectangular notch

First, the simplest reflector is assembled using a flat-bottomed slot with a constant width.

Stepped (V-shaped) notch

Next, a stair stepped V-shaped notch is assembled using the union of three nested rectangles whose widths decrease and whose depths increase from the surface inward. The widths and depths are chosen such as to produce a profile that narrows monotonically with depth while keeping all internal edges axis-aligned.

Crack-like notch

Finally, the third notch consists of a thin, jagged surface-breaking crack. The Crack is fully parameterized, meaning that one could quickly prototype a variety of crack geometries. The random_seed is fixed for this example so that the geometry is reproducible. In a parametric study, one would instead loop over many seeds to sample a population of plausible crack realisations.

Wedge probe

A WedgeProbe2D is placed on the top surface of the specimen so that it fires obliquely toward the notch. The wedge geometry, transducer layout, and damping layer follow the same pattern as the other NDT tutorials:

• origin places the probe near the left edge of the specimen, away from the notch region.
• wedge_angle_in_degrees=45 produces an obliquely incident wavefront in the steel.
• A large number_of_elements is used to synthesise a smooth plane wave.
• damping_depth introduces an absorbing layer on the back face of the wedge that suppresses spurious reverberations from the probe body.

Assembly

Each notch specimen is combined with the probe into a single build123d.Compound. The probe’s wedge and damping sub-bodies are unpacked with *probe.geometry.children and joined with the notched specimen, producing one assembled geometry per notch type. All three assemblies share the same probe but differ in the notch morphology.

Meshing

Each assembly is meshed via Coreform Cubit using the notched_specimen algorithm, a meshing strategy tailored to this class of geometries. In particular, the assignment of suitable element sizes, side sets, and materials is handled automatically by this meshing strategy.

As with the other tutorials, the resolution is governed by reference_frequency and elements_per_wavelength, which together determine the element size required to resolve waves at MAX_FREQUENCY. The labelled regions (wedge, damping, specimen) are assigned to the corresponding material properties through the model.

In order for this tutorial to be run by users that do not have Coreform Cubit installed, examples of each of the meshes are provided in the supplementary data directory. However, if one were to construct these meshes themselves, one could do so using the following command:

meshes = {}

for name, geometry in geometries.items():
    meshes[name] = wscan.mesh.mesh_from_geometry(
        geometry=geometry,
        model={
            "wedge": WEDGE_MATERIAL,
            "damping": WEDGE_MATERIAL,
            "specimen": SPECIMEN_MATERIAL,
        },
        mesh_resolution=sn.MeshResolution(
            reference_frequency=MAX_FREQUENCY,
            elements_per_wavelength=ELEMENTS_PER_WAVELENGTH
        ),
        algorithm=wscan.mesh.algorithms.cubit.notched_specimen.Mesher(
            wscan.mesh.algorithms.cubit.notched_specimen.Options(
                site=SALVUS_FLOW_SITE_NAME
            )
        )
    )

However, for this tutorial, the meshes are instead loaded from disk.

Each generated mesh can be visually inspected to confirm that the notch tip is properly resolved and that the wedge–specimen interface looks reasonable.

Simulation setup

A new Salvus project is initialized from the rectangular-notch mesh; the remaining two meshes are subsequently added as additional simulation configurations under the same project.

The probe’s get_event method instantiates the sources and receivers corresponding to each transducer element. The excitation_mode="longitudinal" specifies that each element radiates longitudinal (compressional) waves into the wedge.

Since all three meshes share the same probe, the same event can be reused for every simulation configuration.

A ToneBurst source time function is used to produce a narrowband excitation centred at approximately three-quarters of the maximum frequency.

In order to compare snapshots between the three simulations at exactly the same physical times, all three runs are forced to use a common time step. The time step is computed mesh-by-mesh from the Courant–Friedrichs–Lewy (CFL) condition, and the smallest of the three is adopted for every simulation. This ensures both stability for the finest mesh while also ensuring that the wavefield snapshots are time-aligned across all three simulations.

A separate UnstructuredMeshSimulationConfiguration is added for each notch geometry, all sharing the same source time function, spectral element order, end time, and absorbing boundary conditions. Absorbing boundary conditions are applied on the left (x0) and right (x1) plate edges, in addition to the probe damping layer (damping) in order to suppress spurious reflections from those boundaries. For the sake of simplicity, sponge layers are disabled by setting width_in_meters=0.0; only first-order absorbing conditions are applied directly on the boundary faces. Any exterior boundaries that are not explicitly assigned a boundary condition are implicitly treated as free surfaces.

As a quick sanity check, the geometry is plotted together with the transducer source positions to confirm that the elements lie on the wedge’s inclined face.

Running the simulation

The three simulations are launched sequentially. In order to keep the volumetric wavefield file sizes manageable, the volumetric output is downsampled in time via sampling_interval_in_time_steps, which is chosen here so that roughly 300 snapshots are produced across the full simulation window. The query(block=True) blocks the cell until each simulation has finished before the next one is launched.

Plotting the data

Once all three simulations have finished, the volumetric wavefield from each one is interpolated onto a common Cartesian grid covering the region around the notch. The interpolation is carried out in the spectral-element basis and, therefore, inherits the full accuracy of the spectral-element solution.

Note: Points in the grid that fall inside the void of each notch, which contains no finite elements, will remain unclaimed during the interpolation. The resulting warning from Salvus can safely be ignored in this case.

Three snapshots are plotted as the incident wavefield arrives at the notch. A common color range (vrange) is used so that the relative amplitudes are directly comparable between the three columns.

In order to visualize the entire wavefield, one can alternatively view the raw simulation output in a third-party visualization tool, such as ParaView. The paths to the simulation output directories for each notch geometry are listed below:

For more details on visualizing wavefields with ParaView, see here.

Extensions to more complex specimens

The notch helpers used above cover the simplest reference geometry (i.e., a rectangular specimen with the SimpleSpecimen class), but any specimen that can be expressed in build123d slots into exactly the same pipeline. As a closing example, a specimen with a flat top surface and a wavy bottom is assembled directly from a series of cubic splines. This example is merely intended to demonstrate the flexibility and customizability of this modeling approach.

Each hump is described by a single cubic spline through three control points, namely the two endpoints on the nominal bottom line and a midpoint that is displaced vertically by WAVY_AMPLITUDE. The sign of the midpoint offset alternates between consecutive humps so that the resulting profile resembles a sinusoid while remaining locally smooth.

The remaining three sides of the specimen (the two vertical edges and the flat top) are constructed as simple straight line segments. All edges are then collected, in order, into a single closed wire from which a planar face can be built.

A notch can then be added to the specimen; a U-shaped notch is considered for this example. For this type of custom geometry, the notch must be manually placed to the correct position and with the desired rotation.

Finally, the notch can be incorporated in the geometry by performing a boolean subtraction between the specimen and the notch.

The remainder of the modeling pipeline would remain the same as from the first parts of this tutorial. That is, a transducer would be added to the geometry, the domain could be meshed, and then a simulation could be run with this geometry.