matscipy.fracture_mechanics package

Submodules

matscipy.fracture_mechanics.clusters module

matscipy.fracture_mechanics.clusters.cluster(el, a0, n, crack_surface=[1, 1, 0], crack_front=[0, 0, 1], lattice=None, shift=None)
matscipy.fracture_mechanics.clusters.diamond(*args, **kwargs)
matscipy.fracture_mechanics.clusters.fcc(*args, **kwargs)
matscipy.fracture_mechanics.clusters.sc(*args, **kwargs)
matscipy.fracture_mechanics.clusters.set_groups(a, n, skin_x, skin_y, central_x=- 0.5, central_y=- 0.5, invert_central=False)

matscipy.fracture_mechanics.crack module

class matscipy.fracture_mechanics.crack.ConstantStrainRate(orig_height, delta_strain, mask=None)

Bases: object

Constraint which increments epsilon_yy at a constant strain rate

Rescaling is applied only to atoms where mask is True (default is all atoms)

adjust_forces(atoms, forces)
adjust_positions(atoms, newpos)
apply_strain(atoms, rigid_constraints=False)

Applies a constant strain to the system.

Parameters

  • atoms (ASE.atoms) – Atomic configuration.

  • rigid_constraints (boolean) – Apply (or not apply) strain to every atom. i.e. allow constrainted atoms to move during strain application

copy()
class matscipy.fracture_mechanics.crack.CubicCrystalCrack(crack_surface, crack_front, C11=None, C12=None, C44=None, stress_state='plane strain', C=None, Crot=None)

Bases: object

Crack in a cubic crystal.

crack_tip_position(x, y, ref_x, ref_y, x0, y0, k, mask=None, residual_func=<function displacement_residual>, method='Powell', return_residuals=False)

Return an estimate of the real crack tip position by minimizing the mean square error of the current configuration relative to the diplacement field obtained for a stress intensity factor k from linear elastic fracture mechanics.

Parameters

  • x (array_like) – x-positions of the atomic system containing the crack.

  • y (array_like) – y-positions of the atomic system containing the crack.

  • ref_x (array_like) – x-positions of the reference crystal.

  • ref_y (array_like) – y-positions of the reference crystal.

  • x0 (float) – Initial guess for the x-coordinate of the crack tip.

  • y0 (float) – Initial guess for the y-coordinate of the crack tip.

  • k (float) – Stress intensity factor.

  • mask (array_like, optional) – Marks the atoms to use for this calculation.

  • residual_func (function) – Function returning per-atom residuals to be minimized.

  • method (str) – Optimization method. See method argument of scipy.optimize.minimize. Additionally, ‘leastsq’ invokes scipy.optimize.leastsq.

  • return_residuals (bool) – Function returns residuals if set to True.

Returns

  • x0 (float) – x-coordinate of the crack tip.

  • y0 (float) – y-coordinate of the crack tip.

  • residuals (array, optional) – Per-atom residuals at end of optimization.

crack_tip_position_y(x, y, ref_x, ref_y, x0, y0, k, mask=None)

Return an estimate of the y-coordinate of the real crack tip position assuming the stress intensity factor is k.

Parameters

  • x (array_like) – x-positions of the atomic system containing the crack.

  • y (array_like) – y-positions of the atomic system containing the crack.

  • ref_x (array_like) – x-positions of the reference crystal.

  • ref_y (array_like) – y-positions of the reference crystal.

  • x0 (float) – Initial guess for the x-coordinate of the crack tip.

  • y0 (float) – Initial guess for the y-coordinate of the crack tip.

  • k (float) – Stress intensity factor.

  • mask (array_like, optional) – Marks the atoms to use for this calculation.

Returns

y0 – y-coordinate of the crack tip

Return type

float

deformation_gradient(ref_x, ref_y, x0, y0, k)

Deformation gradient for a list of cartesian positions.

Parameters

  • ref_x (array_like) – x-positions of the reference crystal.

  • ref_y (array_like) – y-positions of the reference crystal.

  • x0 (float) – x-coordinate of the crack tip.

  • y0 (float) – y-coordinate of the crack tip.

  • k (float) – Stress intensity factor.

Returns

  • ux (array_like) – x-displacements.

  • uy (array_like) – y-displacements.

deformation_gradient_from_cartesian_coordinates(dx, dy, k)

Displacement field in mode I fracture from cartesian coordinates.

deformation_gradient_from_cylinder_coordinates(r, theta, k)

Displacement field in mode I fracture from cylindrical coordinates.

displacements(ref_x, ref_y, x0, y0, k)

Displacement field for a list of cartesian positions.

Parameters

  • ref_x (array_like) – x-positions of the reference crystal.

  • ref_y (array_like) – y-positions of the reference crystal.

  • x0 (float) – x-coordinate of the crack tip.

  • y0 (float) – y-coordinate of the crack tip.

  • k (float) – Stress intensity factor.

Returns

  • ux (array_like) – x-displacements.

  • uy (array_like) – y-displacements.

displacements_from_cartesian_coordinates(dx, dy, k)

Displacement field in mode I fracture from cartesian coordinates.

displacements_from_cylinder_coordinates(r, theta, k)

Displacement field in mode I fracture from cylindrical coordinates.

k1g(surface_energy)

Compute Griffith critical stress intensity in mode I fracture.

Parameters

surface_energy (float) – Surface energy of the respective crystal surface.

Returns

k1g – Stress intensity factor.

Return type

float

k1gsqG()
scale_displacements(x, y, ref_x, ref_y, old_k, new_k)

Rescale atomic positions from stress intensity factor old_k to the new stress intensity factor new_k. This is useful for extrapolation of relaxed positions.

Parameters

  • x (array_like) – x-positions of the atomic system containing the crack.

  • y (array_like) – y-positions of the atomic system containing the crack.

  • ref_x (array_like) – x-positions of the reference crystal.

  • ref_y (array_like) – y-positions of the reference crystal.

  • old_k (float) – Current stress intensity factor.

  • new_k (float) – Stress intensity factor for the output positions.

Returns

  • x (array_like) – New x-positions of the atomic system containing the crack.

  • y (array_like) – New y-positions of the atomic system containing the crack.

stresses(ref_x, ref_y, x0, y0, k)

Stress field for a list of cartesian positions

Parameters

  • ref_x (array_like) – x-positions of the reference crystal.

  • ref_y (array_like) – y-positions of the reference crystal.

  • x0 (float) – x-coordinate of the crack tip.

  • y0 (float) – y-coordinate of the crack tip.

  • k (float) – Stress intensity factor.

Returns

  • sig_x (array_like) – xx-component of the stress tensor

  • sig_y (array_like) – yy-component of the stress tensor

  • sig_xy (array_like) – xy-component of the stress tensor

stresses_from_cartesian_coordinates(dx, dy, k)

Stress field in mode I fracture from cartesian coordinates

stresses_from_cylinder_coordinates(r, theta, k)

Stress field in mode I fracture from cylindrical coordinates

matscipy.fracture_mechanics.crack.G_to_strain(G, E, nu, orig_height)

Convert from energy release rate G to strain for thin strip geometry

Parameters

  • G (float) – Energy release rate in units consistent with E and orig_height

  • E (float) – Young’s modulus relevant for a pull in y direction sigma_yy/eps_yy

  • nu (float) – Poission ratio -eps_yy/eps_xx

  • orig_height (float) – Unstrained height of slab

Returns

strain – Dimensionless ratio (current_height - orig_height)/orig_height

Return type

float

class matscipy.fracture_mechanics.crack.IsotropicStressField(K=None, x0=None, y0=None, sxx0=0.0, syy0=0.0, sxy0=0.0, nu=0.5, stress_state='plane strain')

Bases: object

Calculator to return Irwin near-tip stress field at atomic sites

get_stresses(atoms)
class matscipy.fracture_mechanics.crack.RectilinearAnisotropicCrack

Bases: object

Near field solution for a crack in a rectilinear anisotropic elastic medium. See: G. C. Sih, P. C. Paris and G. R. Irwin, Int. J. Frac. Mech. 1, 189 (1965)

deformation_gradient(r, theta, k)

Deformation gradient tensor in mode I fracture. Positions are passed in cyclinder coordinates.

Parameters

  • r (array_like) – Distances from the crack tip.

  • theta (array_like) – Angles with respect to the plane of the crack.

  • k (float) – Stress intensity factor.

Returns

  • du_dx (array) – Derivatives of displacements parallel to the plane within the plane.

  • du_dy (array) – Derivatives of displacements parallel to the plane perpendicular to the plane.

  • dv_dx (array) – Derivatives of displacements normal to the plane of the crack within the plane.

  • dv_dy (array) – Derivatives of displacements normal to the plane of the crack perpendicular to the plane.

displacements(r, theta, k)

Displacement field in mode I fracture. Positions are passed in cyclinder coordinates.

Parameters

  • r (array_like) – Distances from the crack tip.

  • theta (array_like) – Angles with respect to the plane of the crack.

  • k (float) – Stress intensity factor.

Returns

  • u (array) – Displacements parallel to the plane of the crack.

  • v (array) – Displacements normal to the plane of the crack.

k1g(surface_energy)

K1G, Griffith critical stress intensity in mode I fracture

k1gsqG()
rtheta(u, v, k)

Invert displacement field in mode I fracture, i.e. compute r and theta from displacements.

set_plane_strain(b11, b22, b33, b12, b13, b23, b16, b26, b36, b66)
set_plane_stress(a11, a22, a12, a16, a26, a66)
stresses(r, theta, k)

Stress field in mode I fracture. Positions are passed in cylinder coordinates.

Parameters

  • r (array_like) – Distances from the crack tip.

  • theta (array_like) – Angles with respect to the plane of the crack.

  • k (float) – Stress intensity factor.

Returns

  • sig_x (array) – Diagonal component of stress tensor parallel to the plane of the crack.

  • sig_y (array) – Diagonal component of stress tensor normal to the plane of the crack.

  • sig_xy (array) – Off-diagonal component of the stress tensor.

matscipy.fracture_mechanics.crack.deformation_gradient_residual(r0, crack, x, y, cur, ref_x, ref_y, ref, k, cutoff, mask=None)
matscipy.fracture_mechanics.crack.deformation_gradient_residuals(r0, crack, x, y, cur, ref_x, ref_y, ref, k, cutoff)

Return actual displacement field minus ideal displacement field.

matscipy.fracture_mechanics.crack.displacement_residual(r0, crack, x, y, ref_x, ref_y, k, mask=None, power=1)
matscipy.fracture_mechanics.crack.displacement_residuals(r0, crack, x, y, ref_x, ref_y, k, power=1)

Return actual displacement field minus ideal displacement field, divided by r**alpha.

matscipy.fracture_mechanics.crack.find_tip_broken_bonds(atoms, cutoff, bulk_nn=4, boundary_thickness=None)

Find position of the tip from the atom coordination, i.e. broken bonds. Using the C implementation of ‘neighbour_list’. Returns the tip’s position in cartesian coordinates.

Parameters

  • atoms (ase.Atoms) – Atomic configuration.

  • cutoff (float) – Cutoff distance for neighbour search.

  • bulk_nn (integer) – Number of nearest neighbours for the standard bulk configuration.

  • boundary_buffer (float) – Thickness of the boundaries. Defaults to cutoff distance.

Returns

tip_position – The x and y values are found. The z value is calculated as the midpoint of the depth.

Return type

numpy array

matscipy.fracture_mechanics.crack.find_tip_coordination(a, bondlength=2.6, bulk_nn=4)

Find position of tip in crack cluster from coordination

matscipy.fracture_mechanics.crack.find_tip_stress_field(atoms, r_range=None, initial_params=None, fix_params=None, sigma=None, avg_sigma=None, avg_decay=0.005, calc=None)

Find the position of crack tip by fitting to the isotropic K-field stress

Fit is carried out using fit_crack_stress_field(), and parameters have the same meaning as there.

See also

fit_crack_stress_field()

matscipy.fracture_mechanics.crack.fit_crack_stress_field(atoms, r_range=0.0, 50.0, initial_params=None, fix_params=None, sigma=None, avg_sigma=None, avg_decay=0.005, calc=None, verbose=False)

Perform a least squares fit of near-tip stress field to isotropic solution

Stresses on the atoms are fit to the Irwin K-field singular crack tip solution, allowing the crack position, stress intensity factor and far-field stress components to vary during the fit.

Parameters

  • atoms (Atoms object) –

    Crack system. For the initial fit, the following keys are used from the info dictionary:

    • YoungsModulus

    • PossionRatio_yx

    • G — current energy release rate

    • strain — current applied strain

    • CrackPos — initial guess for crack tip position

    The initial guesses for the stress intensity factor K and far-field stress sigma0 are computed from YoungsModulus, PoissonRatio_yx, G and strain, assuming plane strain in thin strip boundary conditions.

    On exit, new K, sigma0 and CrackPos entries are set in the info dictionary. These values are then used as starting guesses for subsequent fits.

  • r_range (sequence of two floats, optional) – If present, restrict the stress fit to an annular region r_range[0] <= r < r_range[1], centred on the previous crack position (from the CrackPos entry in atoms.info). If r_range is None, fit is carried out for all atoms.

  • initial_params (dict) – Names and initial values of parameters. Missing initial values are guessed from Atoms object.

  • fix_params (dict) – Names and values of parameters to fix during the fit, e.g. {y0: 0.0} to constrain the fit to the line y=0

  • sigma (None or array with shape (len(atoms), 3, 3)) – Explicitly provide the per-atom stresses. Avoids calling Atoms’ calculators get_stresses() method.

  • avg_sigma (None or array with shape (len(atoms), 3, 3)) – If present, use this array to accumulate the time-averaged stress field. Useful when processing a trajectory.

  • avg_decay (real) – Factor by which average stress is attenuated at each step. Should be set to dt/tau where dt is MD time-step and tau is a characteristic averaging time.

  • calc (Calculator object, optional) –

    If present, override the calculator used to compute stresses on the atoms. Default is atoms.get_calculator.

    To use the atom resolved stress tensor pass an instance of the AtomResolvedStressField class.

  • verbose (bool, optional) – If set to True, print additional information about the fit.

Returns

params – Fitted parameters, in a form suitable for passing to IsotropicStressField constructor. These are the stress intensity factor K, the centre of the stress field (x0, y0), and the far field contribution to the stress (sxx0, syy0, sxy0).

Return type

dict with keys [K, x0, y0, sxx0, syy0, sxy0]

matscipy.fracture_mechanics.crack.get_energy_release_rate(atoms)

Return the current energy release rate G for atoms

Result is computed assuming thin strip geometry, and using stored Young’s modulus and Poission ratio and original slab height from atoms.info dictionary.

Also updates G value stored in atoms.info dictionary.

matscipy.fracture_mechanics.crack.get_strain(atoms)

Return the current strain on thin strip configuration atoms

Requires unstrained height of slab to be stored as OrigHeight key in atoms.info dictionary.

Also updates value stored in atoms.info.

matscipy.fracture_mechanics.crack.get_stress_intensity_factor(atoms, stress_state='plane strain')

Compute stress intensity factor K_I

Calls get_energy_release_rate() to compute G, then uses stored YoungsModulus and PoissionRatio_yz values from atoms.info dictionary to compute K_I.

Also updates value stored in atoms.info dictionary.

matscipy.fracture_mechanics.crack.isotropic_modeI_crack_tip_displacement_field(K, G, nu, r, t, stress_state='plane strain')

Compute Irwin singular crack tip displacement field for mode I fracture.

Parameters

  • K (float) – Mode I stress intensity factor. Units should match units of G and r.

  • G (float) – Shear modulus. Units should match units of K and r.

  • nu (float) – Poisson ratio.

  • r (array_like) – Radial distances from crack tip. Can be a multidimensional array to evaluate stress field on a grid.

  • t (array_like) – Angles from horizontal line y=0 ahead of crack tip, measured anticlockwise. Should have same shape as r.

  • stress_state (str) – One of”plane stress” or “plane strain”. Used if xyz_only=False to determine zz stresses.

Returns

  • u (array)

  • v (array) – Displacements. Same shape as r and t.

matscipy.fracture_mechanics.crack.isotropic_modeI_crack_tip_stress_field(K, r, t, xy_only=True, nu=0.5, stress_state='plane strain')

Compute Irwin singular crack tip stress field for mode I fracture.

Parameters

  • K (float) – Mode I stress intensity factor. Units should match units of r.

  • r (array_like) – Radial distances from crack tip. Can be a multidimensional array to evaluate stress field on a grid.

  • t (array_like) – Angles from horzontal line y=0 ahead of crack tip, measured anticlockwise. Should have same shape as r.

  • xy_only (bool) – If True (default) only xx, yy, xy and yx components will be set.

  • nu (float) – Poisson ratio. Used only when xy_only=False, to determine zz stresses

  • stress_state (str) – One of”plane stress” or “plane strain”. Used if xyz_only=False to determine zz stresses.

Returns

sigma

Return type

array with shape r.shape + (3,3)

matscipy.fracture_mechanics.crack.plot_stress_fields(atoms, r_range=None, initial_params=None, fix_params=None, sigma=None, avg_sigma=None, avg_decay=0.005, calc=None)

Fit and plot atomistic and continuum stress fields

Firstly a fit to the Irwin K-field solution is carried out using fit_crack_stress_field(), and parameters have the same meaning as for that function. Then plots of the \(\sigma_{xx}\), \(\sigma_{yy}\), \(\sigma_{xy}\) fields are produced for atomistic and continuum cases, and for the residual error after fitting.

matscipy.fracture_mechanics.crack.print_crack_system(directions)

Pretty printing of crack crystallographic coordinate system

Specified by list of Miller indices for crack_direction (x), cleavage_plane (y) and crack_front (z), each of which should be a sequence of three floats

matscipy.fracture_mechanics.crack.strain_to_G(strain, E, nu, orig_height)

Convert from strain to energy release rate G for thin strip geometry

Parameters

  • strain (float) – Dimensionless ratio (current_height - orig_height)/orig_height

  • E (float) – Young’s modulus relevant for a pull in y direction sigma_yy/eps_yy

  • nu (float) – Poission ratio -eps_yy/eps_xx

  • orig_height (float) – Unstrained height of slab

Returns

G – Energy release rate in units consistent with input (i.e. in eV/A**2 if eV/A/fs units used)

Return type

float

matscipy.fracture_mechanics.crack.thin_strip_displacement_y(x, y, strain, a, b)

Return vertical displacement ramp used to apply initial strain to slab

Strain is increased from 0 to strain over distance \(a <= x <= b\). Region \(x < a\) is rigidly shifted up/down by strain*height/2.

Here is an example of how to use this function on an artificial 2D square atomic lattice. The positions are plotted before (left) and after (right) applying the displacement, and the horizontal and vertical lines show the strain (red), a (green) and b (blue) parameters.

import matplotlib.pyplot as plt
import numpy as np

w = 1; h = 1; strain = 0.1; a = -0.5; b =  0.0
x = np.linspace(-w, w, 20)
y = np.linspace(-h, h, 20)
X, Y = np.meshgrid(x, y)
u_y = thin_strip_displacement_y(X, Y, strain, a, b)

for i, disp in enumerate([0, u_y]):
    plt.subplot(1,2,i+1)
    plt.scatter(X, Y + disp, c='k', s=5)
    for y in [-h, h]:
        plt.axhline(y, color='r', linewidth=2, linestyle='dashed')
        plt.axhline(y*(1+strain), color='r', linewidth=2)
    for x, c in zip([a, b], ['g', 'b']):
        plt.axvline(x, color=c, linewidth=2)
thin-strip-displacement-y.png
Parameters

  • x (array) –

  • y (array) – Atomic positions in unstrained slab, centered on origin x=0,y=0

  • strain (float) – Far field strain to apply

  • a (float) – x coordinate for beginning of strain ramp

  • b (float) – x coordinate for end of strain ramp

matscipy.fracture_mechanics.crackpathsel module

function coordination(r, cutoff, transition_width)
if r > cutoff

f = 0.0 df = 0.0

elseif r > cutoff-transition_width

f = 0.5 * ( cos(pi*(r-cutoff+transition_width)/transition_width) + 1.0 ) df = - 0.5 * pi * sin(pi*(r-cutoff+transition_width)/transition_width) / transition_width

else

f = 1.0 df = 0.0

end f

end

function dcoordination(r, cutoff, transition_width)
if r > cutoff

df = 0.0

elseif r > cutoff-transition_width

df = - 0.5 * pi * sin(pi*(r-cutoff+transition_width)/transition_width) / transition_width

else

df = 0.0

end df

end

function energy(pos, neighb_j, neighb_rij, cutoff, transition_width, epsilon)

N = size(pos, 2)

n = zeros(Float64, N) energies = zeros(Float64, N)

for i = 1:N
for (m, j) in enumerate(neighb_j[i])

r_ij = neighb_rij[i][m] #@printf(“i %d j %d r_ij %f

“, i, j, r_ij)

r_ij > cutoff && continue

f_ij = coordination(r_ij, cutoff, transition_width) n[i] += f_ij

end energies[i] += (n[i] - 3)^2

end

for i = 1:N

sum_B_ij = 0.0

for (m, j) in enumerate(neighb_j[i])

r_ij = neighb_rij[i][m] r_ij > cutoff && continue

f_ij = coordination(r_ij, cutoff, transition_width) B_ij = (n[j] - 3.0)^2*f_ij sum_B_ij += B_ij

end

Eb_i = epsilon*(n[i] - 3.0)^2*sum_B_ij energies[i] += Eb_i

end

E = sum(energies) return (E, energies, n)

end

function force(pos, neighb_j, neighb_rij, cutoff, transition_width, epsilon, dx)

N = size(pos, 2) f = zeros(Float64, (3, N)) p = zeros(Float64, (3, N))

p[:, :] = pos for i = 1:N

for j = 1:3

p[j, i] += dx ep, local_e_p, n_p = energy(p, neighb_j, neighb_rij, cutoff, transition_width, epsilon) p[j, i] -= 2dx em, local_e_m, n_m = energy(p, neighb_j, neighb_rij, cutoff, transition_width, epsilon) f[j, i] = -(ep - em)/(2dx) p[j, i] += dx

end

end f

end

matscipy.fracture_mechanics.energy_release module

matscipy.fracture_mechanics.energy_release.J_integral(a, deformation_gradient, virial, epot, e0, tip_x, tip_y, r1, r2, mask=None)

Compute the energy release rate from the J-integral. Converts contour integral into a domain integral. See: Li, Shih, Needleman, Eng. Fract. Mech. 21, 405 (1985); Jin, Yuan, J. Nanosci. Nanotech. 5, 2099 (2005) Domain function is currently fixed: q(r) = (r-r1)/(r2-r1)

Parameters

  • a (ase.Atoms) – Relaxed atomic configuration of the crack.

  • deformation_gradient (array_like) – len(a) x 3x3 array of atomic deformation gradients.

  • virial (array_like) – len(a) x 3x3 array of atomic virials.

  • epot (float) – Potential energy per atom of the cracked configuration.

  • e0 (float) – Reference energy (cohesive energy per atom of the bulk crystal at equilibrium).

  • tip_y (tip_x,) – Position of the crack tip.

  • r2 (r1,) – Volume integration is carried out in region at a distance between r1 and r2 from the crack tip.

  • mask (array_like) – Include only a subset of all atoms into J-integral computation.

Returns

J – Value of the J-integral.

Return type

float

matscipy.fracture_mechanics.idealbrittlesolid module

class matscipy.fracture_mechanics.idealbrittlesolid.IdealBrittleSolid(*args, **kwargs)

Bases: ase.calculators.calculator.Calculator

Implementation of force field for an ideal brittle solid

Described in Marder, Int. J. Fract. 130, 517-555 (2004)

calculate(atoms, properties, system_changes)

Do the calculation.

properties: list of str

List of what needs to be calculated. Can be any combination of ‘energy’, ‘forces’, ‘stress’, ‘dipole’, ‘charges’, ‘magmom’ and ‘magmoms’.

system_changes: list of str

List of what has changed since last calculation. Can be any combination of these six: ‘positions’, ‘numbers’, ‘cell’, ‘pbc’, ‘initial_charges’ and ‘initial_magmoms’.

Subclasses need to implement this, but can ignore properties and system_changes if they want. Calculated properties should be inserted into results dictionary like shown in this dummy example:

self.results = {'energy': 0.0,
                'forces': np.zeros((len(atoms), 3)),
                'stress': np.zeros(6),
                'dipole': np.zeros(3),
                'charges': np.zeros(len(atoms)),
                'magmom': 0.0,
                'magmoms': np.zeros(len(atoms))}

The subclass implementation should first call this implementation to set the atoms attribute.

default_parameters = {'a': 1.0, 'b': 0.01, 'beta': 0.01, 'k': 1.0, 'linear': False, 'rc': 1.01}
get_elastic_moduli()

Return Lam’e constants lambda and mu

get_poisson_ratio()
get_wave_speeds(atoms)

Return longitudinal, shear and Rayleigh wave speeds

get_youngs_modulus()
implemented_properties = ['energy', 'energies', 'stress', 'forces']
set_reference_crystal(crystal)
matscipy.fracture_mechanics.idealbrittlesolid.extend_strip(atoms, a, N, M, vacuum)
matscipy.fracture_mechanics.idealbrittlesolid.find_crack_tip(atoms, dt=None, store=True, results=None)

Return atom at the crack tip and its x-coordinate

Crack tip is defined to be location of rightmost atom whose nearest neighbour is at distance > 2.5*a

matscipy.fracture_mechanics.idealbrittlesolid.find_triangles_2d(atoms, cutoff, minangle=0.5235987755982988, maxangle=2.0943951023931953, xdim=0, ydim=1)

Return a list of all triangles of a triangular lattice sitting in the x-y plane.

matscipy.fracture_mechanics.idealbrittlesolid.set_constraints(c, a)
matscipy.fracture_mechanics.idealbrittlesolid.set_initial_velocities(c)

Initialise a dynamical state by kicking some atoms behind tip

matscipy.fracture_mechanics.idealbrittlesolid.triangular_lattice_slab(a, n, m)

Module contents