Пример #1
0
    def __run_rand_dyn__(self, mid, T1, T2, dt, Nc, Ns, dS):
        # Setup calculator
        mol = self.mols[0].copy()

        # Setup PBC if active
        if self.pbc:
            mol.set_cell(([[self.pbl, 0, 0],
                           [0, self.pbl, 0],
                           [0, 0, self.pbl]]))

            mol.set_pbc((self.pbc, self.pbc, self.pbc))

        # Setup calculator
        mol.set_calculator(ANIENS(self.aens))

        #mol.set_calculator(ANI(False))
        #mol.calc.setnc(self.ncl[0])

        # Set chemical symbols
        spc = mol.get_chemical_symbols()

        # Set the velocities corresponding to a boltzmann dist @ T/4.0
        MaxwellBoltzmannDistribution(mol, T1 * units.kB)

        # Set the thermostat
        dyn = Langevin(mol, dt * units.fs, T1 * units.kB, 0.02)
        dT = (T2 - T1)/Nc
        #print('Running...')
        for i in range(Nc):
            # Set steps temperature
            dyn.set_temperature((T1 + dT*i) * units.kB)

            # Do Ns steps of dynamics
            dyn.run(Ns)

            # Return sigma
            sigma = hdt.evtokcal * mol.calc.stddev

            ekin = mol.get_kinetic_energy() / len(mol)

            # Check for dynamics failure
            if sigma > dS:
                self.Nbad += 1
                self.X.append(mol.get_positions())
                #print('Step:', dyn.get_number_of_steps(), 'Sig:', sigma, 'Temp:',
                #      str(ekin / (1.5 * units.kB)) + '(' + str(T1 + dT * i) + ')')

                return True,dyn.get_number_of_steps()
        return False,dyn.get_number_of_steps()
           results=crack_pos)

# run for 2000 time steps to reach steady state at initial load
for i in range(20):
    dyn.run(100)
    if extend_strip(dyn.atoms, params.a, params.N, params.M, params.vacuum):
        set_constraints(dyn.atoms, params.a)

# start decreasing strain
#set_constraints(dyn.atoms, params.a, delta_strain=delta_strain)

strain_atoms = ConstantStrainRate(dyn.atoms.info['OrigHeight'], delta_strain)
dyn.attach(strain_atoms.apply_strain, 1, dyn.atoms)

for i in range(50):
    dyn.run(100)
    if extend_strip(dyn.atoms, params.a, params.N, params.M, params.vacuum):
        set_constraints(dyn.atoms, params.a)

del dyn.observers[-1]  # stop increasing the strain

for i in range(1000):
    dyn.run(100)
    if extend_strip(dyn.atoms, params.a, params.N, params.M, params.vacuum):
        set_constraints(dyn.atoms, params.a)

traj.close()

time = 10.0 * dyn.dt * np.arange(dyn.get_number_of_steps() / 10)
np.savetxt('crackpos.dat', np.c_[time, crack_pos])