4.4 Crack tip correction

Iterative crack tip correction

The line intercept method can only give an estimate of the crack tip position as it is sensitive to the threshold value eps_vm_threshold. Whereas, the machine learning-based crack detection is generally very effective, it is still advisable to perform a crosscheck in certain cases to ensure accuracy. Therefore, we use the iterative crack tip correction algorithm for further adjustment, which is based on the Williams series coefficients of the crack tip field. This method was proposed by Réthoré (Réthoré '15) and incorporates even negative Williams series terms, also known as super-singular terms, to find the position of the crack tip under pure mode I loading: $d_{x}=-2 \cdot \frac{A_{-1}}{A_{1}}$. To find a correction formula also in the y-direction and for mixed mode loading, we used a deep symbolic regression technique (Melching et al. '24, Code). The iterative correction algorithm is based on the property that the Williams coefficients $A_{-1}$ and $B_{-1}$ become zero at the correct crack tip position.

In the following, we want to optimise the crack tip position based on the first estimation of the line intercept method. To do this, we need to import and initialise the method.

from crackpy.crack_detection.correction import CrackTipCorrection, CrackTipCorrectionGridSearch
correction = CrackTipCorrection(data, cd.crack_tip, cd.crack_angle, material)

Then define the properties for the crack tip field fit:

from crackpy.fracture_analysis.optimization import OptimizationProperties
opt_props = OptimizationProperties(
    angle_gap=10,
    min_radius=3,
    max_radius=8,
    tick_size=0.1,
    terms=[-1, 0, 1, 2]
)

And start the iterative crack tip correction:

crack_tip_corr = correction.correct_crack_tip(
    opt_props,
    max_iter=100,
    step_tol=0.005,
    damper=1,
    method='symbolic_regression',
    verbose=True,
    plot_intermediate_results=True,
    cd=cd,
    folder=os.path.join(OUTPUT_PATH, 'crack_tip_correction')
    d_x_str=None,
    d_y_str=None,
)

Where max_iter is the maximum number of iterations, step_tol is the convergence criterion and damper can be used to smooth the correction step. The method parameter defines the correction algorithm. The following options are available:

Parameter	$d_x$	$d_y$
method='rethore'	$d_x=-2 \cdot \frac{A_{-1}}{ A_{1}}$	$d_y=0$
method='symbolic_regression'	$d_x=- \frac{A_{-1}}{ A_{1}}$	$d_y=- \frac{B_{-1}}{ A_{1}}$
method='custom_function'	d_x_str	d_y_str

A custom crack tip correction function can be defined using the optional d_x_str and d_y_str parameters. Python code can be passed using a string statement, as shown subsequently:

    method='custom_function',
    d_x_str="-2.0 * williams_fit_a_n[-1] / williams_fit_a_n[1]",
    d_y_str="-2.5 * williams_fit_b_n[-1] / williams_fit_a_n[1]",

Finally, we can plot the results:

cd.plot(fname=NODEMAP_FILE[:-4] + '.png', folder=os.path.join(OUTPUT_PATH, 'crack_tip_correction'),
        crack_tip_results=results_corr, fmax=material.sig_yield)

This is an example of high-resolution digital image correlation data of the plastic zone of a fatigue crack in AA2024-T3 aluminium alloy:

Convergence animation	Convergence plot

Optimization algorithm

Instead of using the Williams coefficients $A_{-1}$ and $B_{-1}$, the optimization algorithm aims to minimize the residual of the entire Williams field. The algorithm uses the scipy.optimize.minimize method.

crack_tip_corr_opt = correction.correct_crack_tip_optimization(
    opt_props,
    tol=0.01,
    objective='error',
    verbose=True
)

Grid search

The grid search method is a computationally expensive brute force approach for academic research. It involves defining a regular grid around a given crack tip position and fitting the Williams field for every grid point. The grid point with the smallest fitting residual is then assumed to be the true crack tip position.

correction_grid = CrackTipCorrectionGridSearch(data, crack_tip, crack_angle, material)
crack_tip_corr_grid, df_grid_errors = correction_grid.correct_crack_tip_grid_search(
    opt_props,
    x_min=-3,
    x_max=3,
    y_min=-3,
    y_max=3,
    x_step=1,
    y_step=1,
    workers=20,
    verbose=True
)
plot_grid_errors(df_grid_errors, fname=NODEMAP_FILE[:-4] + '_errors.png', folder=os.path.join(OUTPUT_PATH, 'errors'))
df_grid_errors.to_csv(os.path.join(OUTPUT_PATH, 'errors', NODEMAP_FILE[:-4] + '_errors.csv'), index=False)