コード例 #1
0
 def test_forces_linear(self):
     a = triangular_lattice_slab(1.0, 1, 1)
     calc = IdealBrittleSolid(rc=1.2, beta=0.0, linear=True)
     calc.set_reference_crystal(a)
     a.set_calculator(calc)
     a.rattle(0.01)
     f = a.get_forces()
     fn = calc.calculate_numerical_forces(a)
     self.assertArrayAlmostEqual(f, fn, tol=self.tol)
コード例 #2
0
 def test_forces_and_virial(self):
     a = triangular_lattice_slab(1.0, 2, 2)
     calc = IdealBrittleSolid(rc=1.2, beta=0.0)
     a.set_calculator(calc)
     a.rattle(0.1)
     f = a.get_forces()
     fn = calc.calculate_numerical_forces(a)
     self.assertArrayAlmostEqual(f, fn, tol=self.tol)
     self.assertArrayAlmostEqual(a.get_stress(),
                                 calc.calculate_numerical_stress(a),
                                 tol=self.tol)
コード例 #3
0
    def test_anisotropic_near_field_solution(self):
        """
        Run an atomistic calculation of a harmonic solid and compare to
        continuum solution.
        """

        for nx in [8, 16, 32, 64]:
            for calc, a, C11, C12, C44, surface_energy, bulk_coordination in [
                    #( atomistica.DoubleHarmonic(k1=1.0, r1=1.0, k2=1.0,
                    #                            r2=math.sqrt(2), cutoff=1.6),
                    #  clusters.sc('He', 1.0, [nx,nx,1], [1,0,0], [0,1,0]),
                    #  3, 1, 1, 0.05, 6 ),
                (
                    #atomistica.Harmonic(k=1.0, r0=1.0, cutoff=1.3, shift=True),
                    IdealBrittleSolid(k=1.0, a=1.0, rc=1.3),
                    clusters.fcc('He', math.sqrt(2.0), [nx, nx, 1], [1, 0, 0],
                                 [0, 1, 0]),
                    math.sqrt(2),
                    1.0 / math.sqrt(2),
                    1.0 / math.sqrt(2),
                    0.05,
                    12)
            ]:
                clusters.set_groups(a, (nx, nx, 1), 0.5, 0.5)
                crack = CubicCrystalCrack([1, 0, 0], [0, 1, 0], C11, C12, C44)

                a.center(vacuum=20.0, axis=0)
                a.center(vacuum=20.0, axis=1)
                a.set_calculator(calc)

                sx, sy, sz = a.cell.diagonal()
                tip_x = sx / 2
                tip_y = sy / 2

                k1g = crack.k1g(surface_energy)
                r0 = a.positions.copy()

                u, v = crack.displacements(a.positions[:, 0], a.positions[:,
                                                                          1],
                                           tip_x, tip_y, k1g)
                a.positions[:, 0] += u
                a.positions[:, 1] += v

                g = a.get_array('groups')
                a.set_constraint(FixAtoms(mask=g == 0))

                #ase.io.write('initial_{}.xyz'.format(nx), a, format='extxyz', write_results=False)

                x1, y1, z1 = a.positions.copy().T
                FIRE(a, logfile=None).run(fmax=1e-3)
                x2, y2, z2 = a.positions.T

                # Get coordination numbers and find properly coordinated atoms
                i = neighbour_list("i", a, 1.1)
                coord = np.bincount(i, minlength=len(a))
                mask = coord == bulk_coordination

                residual = np.sqrt(((x2 - x1) / u)**2 + ((y2 - y1) / v)**2)

                #a.set_array('residual', residual)
                #ase.io.write('final_{}.xyz'.format(nx), a, format='extxyz')

                #print(np.max(residual[mask]))
                self.assertTrue(np.max(residual[mask]) < 0.2)
コード例 #4
0
from ase.md import VelocityVerlet
from ase.optimize.fire import FIRE

from matscipy.fracture_mechanics.idealbrittlesolid import (IdealBrittleSolid,
                                                           triangular_lattice_slab,
                                                           find_crack_tip,
                                                           set_initial_velocities,
                                                           set_constraints,
                                                           extend_strip)
                                                           
from matscipy.fracture_mechanics.crack import thin_strip_displacement_y

sys.path.insert(0, '.')
import params

calc = IdealBrittleSolid(rc=params.rc, k=params.k, a=params.a, beta=params.beta)

x_dimer = np.linspace(params.a-(params.rc-params.a),
                      params.a+1.1*(params.rc-params.a),51)
dimers = [Atoms('Si2', [(0, 0, 0), (x, 0, 0)],
                cell=[10., 10., 10.], pbc=True) for x in x_dimer]
calc.set_reference_crystal(dimers[0])
e_dimer = []
f_dimer = []
f_num = []
for d in dimers:
    d.set_calculator(calc)
    e_dimer.append(d.get_potential_energy())
    f_dimer.append(d.get_forces())
    f_num.append(calc.calculate_numerical_forces(d))
e_dimer = np.array(e_dimer)
コード例 #5
0
from ase.optimize.fire import FIRE

from matscipy.fracture_mechanics.idealbrittlesolid import (IdealBrittleSolid,
                                                           triangular_lattice_slab,
                                                           find_crack_tip,
                                                           set_initial_velocities,
                                                           set_constraints,
                                                           extend_strip)

from matscipy.fracture_mechanics.crack import (thin_strip_displacement_y,
                                               ConstantStrainRate)

sys.path.insert(0, '.')
import params

calc = IdealBrittleSolid(rc=params.rc, k=params.k, a=params.a, beta=params.beta)

x_dimer = np.linspace(params.a-(params.rc-params.a),
                      params.a+1.1*(params.rc-params.a),51)
dimers = [Atoms('Si2', [(0, 0, 0), (x, 0, 0)],
                cell=[10., 10., 10.], pbc=True) for x in x_dimer]
calc.set_reference_crystal(dimers[0])
e_dimer = []
f_dimer = []
f_num = []
for d in dimers:
    d.set_calculator(calc)
    e_dimer.append(d.get_potential_energy())
    f_dimer.append(d.get_forces())
    f_num.append(calc.calculate_numerical_forces(d))
e_dimer = np.array(e_dimer)