def build_system(self, name): try: # Known molecule or atom? atoms = molecule(name) if len(atoms) == 2 and self.bond_length is not None: atoms.set_distance(0, 1, self.bond_length) except NotImplementedError: symbols = string2symbols(name) if len(symbols) == 1: magmom = ground_state_magnetic_moments[atomic_numbers[ symbols[0]]] atoms = Atoms(name, magmoms=[magmom]) elif len(symbols) == 2: # Dimer if self.bond_length is None: b = (covalent_radii[atomic_numbers[symbols[0]]] + covalent_radii[atomic_numbers[symbols[1]]]) else: b = self.bond_length atoms = Atoms(name, positions=[(0, 0, 0), (b, 0, 0)]) else: raise ValueError('Unknown molecule: ' + name) if self.unit_cell is None: atoms.center(vacuum=self.vacuum) else: atoms.cell = self.unit_cell atoms.center() return atoms
def build_system(self, name): try: # Known molecule or atom? atoms = molecule(name) if len(atoms) == 2 and self.bond_length is not None: atoms.set_distance(0, 1, self.bond_length) except NotImplementedError: symbols = string2symbols(name) if len(symbols) == 1: Z = atomic_numbers[symbols[0]] magmom = ground_state_magnetic_moments[Z] atoms = Atoms(name, magmoms=[magmom]) elif len(symbols) == 2: # Dimer if self.bond_length is None: b = (covalent_radii[atomic_numbers[symbols[0]]] + covalent_radii[atomic_numbers[symbols[1]]]) else: b = self.bond_length atoms = Atoms(name, positions=[(0, 0, 0), (b, 0, 0)]) else: raise ValueError('Unknown molecule: ' + name) if self.unit_cell is None: atoms.center(vacuum=self.vacuum) else: atoms.cell = self.unit_cell atoms.center() return atoms
def build_molecule(args): try: # Known molecule or atom? atoms = molecule(args.name) except NotImplementedError: symbols = string2symbols(args.name) if len(symbols) == 1: Z = atomic_numbers[symbols[0]] magmom = ground_state_magnetic_moments[Z] atoms = Atoms(args.name, magmoms=[magmom]) elif len(symbols) == 2: # Dimer if args.bond_length is None: b = (covalent_radii[atomic_numbers[symbols[0]]] + covalent_radii[atomic_numbers[symbols[1]]]) else: b = args.bond_length atoms = Atoms(args.name, positions=[(0, 0, 0), (b, 0, 0)]) else: raise ValueError('Unknown molecule: ' + args.name) else: if len(atoms) == 2 and args.bond_length is not None: atoms.set_distance(0, 1, args.bond_length) if args.unit_cell is None: if args.vacuum: atoms.center(vacuum=args.vacuum) else: atoms.center(about=[0, 0, 0]) else: a = [float(x) for x in args.unit_cell.split(',')] if len(a) == 1: cell = [a[0], a[0], a[0]] elif len(a) == 3: cell = a else: a, b, c, alpha, beta, gamma = a degree = np.pi / 180.0 cosa = np.cos(alpha * degree) cosb = np.cos(beta * degree) sinb = np.sin(beta * degree) cosg = np.cos(gamma * degree) sing = np.sin(gamma * degree) cell = [[a, 0, 0], [b * cosg, b * sing, 0], [c * cosb, c * (cosa - cosb * cosg) / sing, c * np.sqrt( sinb**2 - ((cosa - cosb * cosg) / sing)**2)]] atoms.cell = cell atoms.center() atoms.pbc = args.periodic return atoms
def parse_relax(label, write_traj=False, pbc=False, cell=None, chemical_symbols=[]): f = open(label + '.relax') #f = open(label + '.restart') text = f.read() # Parse out the steps if text == '': return None steps = text.split(':RELAXSTEP:')[1:] if write_traj == False: steps = [steps[-1]] else: traj = Trajectory(label + '.traj', mode='w') # Parse out the energies n_geometric = len(steps) s = os.popen('grep "Total free energy" ' + label + '.out') engs = s.readlines()[-n_geometric:] engs = [float(a.split()[-2]) * Hartree for a in engs] s.close() # build a traj file out of the steps for j, step in enumerate(steps): positions = step.split(':')[2].strip().split('\n') forces = step.split(':')[4].strip().split('\n') frc = np.empty((len(forces), 3)) atoms = Atoms() for i, f in enumerate(forces): frc[i, :] = [float(a) * Hartree / Bohr for a in f.split()] atoms += Atom(chemical_symbols[i], [float(a) * Bohr for a in positions[i].split()]) atoms.set_calculator( SinglePointCalculator(atoms, energy=engs[j], forces=frc)) atoms.set_pbc(pbc) atoms.cell = cell if write_traj == True: traj.write(atoms) atoms.set_calculator() return atoms
def graphene_nanoribbon(n, m, type='zigzag', saturated=False, C_H=1.09, C_C=1.42, vacuum=None, magnetic=False, initial_mag=1.12, sheet=False, main_element='C', saturate_element='H'): """Create a graphene nanoribbon. Creates a graphene nanoribbon in the x-z plane, with the nanoribbon running along the z axis. Parameters: n: int The width of the nanoribbon. For armchair nanoribbons, this n may be half-integer to repeat by half a cell. m: int The length of the nanoribbon. type: str The orientation of the ribbon. Must be either 'zigzag' or 'armchair'. saturated: bool If true, hydrogen atoms are placed along the edge. C_H: float Carbon-hydrogen bond length. Default: 1.09 Angstrom. C_C: float Carbon-carbon bond length. Default: 1.42 Angstrom. vacuum: None (default) or float Amount of vacuum added to non-periodic directions, if present. magnetic: bool Make the edges magnetic. initial_mag: float Magnitude of magnetic moment if magnetic. sheet: bool If true, make an infinite sheet instead of a ribbon (default: False) """ if m % 1 != 0: raise ValueError('m must be integer') if type == 'zigzag' and n % 1 != 0: raise ValueError('n must be an integer for zigzag ribbons') b = sqrt(3) * C_C / 4 arm_unit = Atoms(main_element + '4', pbc=(1, 0, 1), cell=[4 * b, 0, 3 * C_C]) arm_unit.positions = [[0, 0, 0], [b * 2, 0, C_C / 2.], [b * 2, 0, 3 * C_C / 2.], [0, 0, 2 * C_C]] arm_unit_half = Atoms(main_element + '2', pbc=(1, 0, 1), cell=[2 * b, 0, 3 * C_C]) arm_unit_half.positions = [[b * 2, 0, C_C / 2.], [b * 2, 0, 3 * C_C / 2.]] zz_unit = Atoms(main_element + '2', pbc=(1, 0, 1), cell=[3 * C_C / 2.0, 0, b * 4]) zz_unit.positions = [[0, 0, 0], [C_C / 2.0, 0, b * 2]] atoms = Atoms() if type == 'zigzag': edge_index0 = np.arange(m) * 2 edge_index1 = (n - 1) * m * 2 + np.arange(m) * 2 + 1 if magnetic: mms = np.zeros(m * n * 2) for i in edge_index0: mms[i] = initial_mag for i in edge_index1: mms[i] = -initial_mag for i in range(n): layer = zz_unit.repeat((1, 1, m)) layer.positions[:, 0] += 3 * C_C / 2 * i if i % 2 == 1: layer.positions[:, 2] += 2 * b layer[-1].position[2] -= b * 4 * m atoms += layer xmin = atoms.positions[0, 0] if magnetic: atoms.set_initial_magnetic_moments(mms) if saturated: H_atoms0 = Atoms(saturate_element + str(m)) H_atoms0.positions = atoms[edge_index0].positions H_atoms0.positions[:, 0] -= C_H H_atoms1 = Atoms(saturate_element + str(m)) H_atoms1.positions = atoms[edge_index1].positions H_atoms1.positions[:, 0] += C_H atoms += H_atoms0 + H_atoms1 atoms.cell = [n * 3 * C_C / 2, 0, m * 4 * b] elif type == 'armchair': n *= 2 n_int = int(round(n)) if abs(n_int - n) > 1e-10: raise ValueError( 'The argument n has to be half-integer for armchair ribbons.') n = n_int for i in range(n // 2): layer = arm_unit.repeat((1, 1, m)) layer.positions[:, 0] -= 4 * b * i atoms += layer if n % 2: layer = arm_unit_half.repeat((1, 1, m)) layer.positions[:, 0] -= 4 * b * (n // 2) atoms += layer xmin = atoms.positions[-1, 0] if saturated: if n % 2: arm_right_saturation = Atoms(saturate_element + '2', pbc=(1, 0, 1), cell=[2 * b, 0, 3 * C_C]) arm_right_saturation.positions = [[ -sqrt(3) / 2 * C_H, 0, C_C / 2 - C_H * 0.5 ], [-sqrt(3) / 2 * C_H, 0, 3 * C_C / 2.0 + C_H * 0.5]] else: arm_right_saturation = Atoms(saturate_element + '2', pbc=(1, 0, 1), cell=[4 * b, 0, 3 * C_C]) arm_right_saturation.positions = [[ -sqrt(3) / 2 * C_H, 0, C_H * 0.5 ], [-sqrt(3) / 2 * C_H, 0, 2 * C_C - C_H * 0.5]] arm_left_saturation = Atoms(saturate_element + '2', pbc=(1, 0, 1), cell=[4 * b, 0, 3 * C_C]) arm_left_saturation.positions = [[ b * 2 + sqrt(3) / 2 * C_H, 0, C_C / 2 - C_H * 0.5 ], [b * 2 + sqrt(3) / 2 * C_H, 0, 3 * C_C / 2.0 + C_H * 0.5]] arm_right_saturation.positions[:, 0] -= 4 * b * (n / 2.0 - 1) atoms += arm_right_saturation.repeat((1, 1, m)) atoms += arm_left_saturation.repeat((1, 1, m)) atoms.cell = [b * 4 * n / 2.0, 0, 3 * C_C * m] atoms.set_pbc([sheet, False, True]) # The ribbon was 'built' from x=0 towards negative x. # Move the ribbon to positive x: atoms.positions[:, 0] -= xmin if not sheet: atoms.cell[0] = 0.0 if vacuum is not None: atoms.center(vacuum, axis=1) if not sheet: atoms.center(vacuum, axis=0) return atoms
def graphene_nanoribbon(n, m, type='zigzag', saturated=False, C_H=1.09, C_C=1.42, vacuum=None, magnetic=False, initial_mag=1.12, sheet=False, main_element='C', saturate_element='H'): """Create a graphene nanoribbon. Creates a graphene nanoribbon in the x-z plane, with the nanoribbon running along the z axis. Parameters: n: int The width of the nanoribbon. m: int The length of the nanoribbon. type: str The orientation of the ribbon. Must be either 'zigzag' or 'armchair'. saturated: bool If true, hydrogen atoms are placed along the edge. C_H: float Carbon-hydrogen bond length. Default: 1.09 Angstrom. C_C: float Carbon-carbon bond length. Default: 1.42 Angstrom. vacuum: None (default) or float Amount of vacuum added to non-periodic directions, if present. magnetic: bool Make the edges magnetic. initial_mag: float Magnitude of magnetic moment if magnetic. sheet: bool If true, make an infinite sheet instead of a ribbon (default: False) """ b = sqrt(3) * C_C / 4 arm_unit = Atoms(main_element + '4', pbc=(1, 0, 1), cell=[4 * b, 0, 3 * C_C]) arm_unit.positions = [[0, 0, 0], [b * 2, 0, C_C / 2.], [b * 2, 0, 3 * C_C / 2.], [0, 0, 2 * C_C]] zz_unit = Atoms(main_element + '2', pbc=(1, 0, 1), cell=[3 * C_C / 2.0, 0, b * 4]) zz_unit.positions = [[0, 0, 0], [C_C / 2.0, 0, b * 2]] atoms = Atoms() if type == 'zigzag': edge_index0 = np.arange(m) * 2 + 1 edge_index1 = (n - 1) * m * 2 + np.arange(m) * 2 if magnetic: mms = np.zeros(m * n * 2) for i in edge_index0: mms[i] = initial_mag for i in edge_index1: mms[i] = -initial_mag for i in range(n): layer = zz_unit.repeat((1, 1, m)) layer.positions[:, 0] -= 3 * C_C / 2 * i if i % 2 == 1: layer.positions[:, 2] += 2 * b layer[-1].position[2] -= b * 4 * m atoms += layer if magnetic: atoms.set_initial_magnetic_moments(mms) if saturated: H_atoms0 = Atoms(saturate_element + str(m)) H_atoms0.positions = atoms[edge_index0].positions H_atoms0.positions[:, 0] += C_H H_atoms1 = Atoms(saturate_element + str(m)) H_atoms1.positions = atoms[edge_index1].positions H_atoms1.positions[:, 0] -= C_H atoms += H_atoms0 + H_atoms1 atoms.cell = [n * 3 * C_C / 2, 0, m * 4 * b] elif type == 'armchair': for i in range(n): layer = arm_unit.repeat((1, 1, m)) layer.positions[:, 0] -= 4 * b * i atoms += layer if saturated: arm_right_saturation = Atoms(saturate_element + '2', pbc=(1, 0, 1), cell=[4 * b, 0, 3 * C_C]) arm_right_saturation.positions = [[ -sqrt(3) / 2 * C_H, 0, C_H * 0.5 ], [-sqrt(3) / 2 * C_H, 0, 2 * C_C - C_H * 0.5]] arm_left_saturation = Atoms(saturate_element + '2', pbc=(1, 0, 1), cell=[4 * b, 0, 3 * C_C]) arm_left_saturation.positions = [[ b * 2 + sqrt(3) / 2 * C_H, 0, C_C / 2 - C_H * 0.5 ], [b * 2 + sqrt(3) / 2 * C_H, 0, 3 * C_C / 2.0 + C_H * 0.5]] arm_right_saturation.positions[:, 0] -= 4 * b * (n - 1) atoms += arm_right_saturation.repeat((1, 1, m)) atoms += arm_left_saturation.repeat((1, 1, m)) atoms.cell = [b * 4 * n, 0, 3 * C_C * m] atoms.set_pbc([sheet, False, True]) atoms.set_scaled_positions(atoms.get_scaled_positions() % 1.0) if not sheet: atoms.cell[0] = 0.0 if vacuum: atoms.center(vacuum, axis=1) if not sheet: atoms.center(vacuum, axis=0) return atoms
#!/usr/bin/env python from xcp2k import CP2K from ase.atoms import Atom, Atoms from ase.lattice import bulk import numpy as np from multiprocessing import Pool, Process import os atoms = Atoms([Atom('Pt', (0, 0, 0))]) atoms.cell=0.5 * 3.96 * np.array([[1.0, 1.0, 0.0], [0.0, 1.0, 1.0], [1.0, 0.0, 1.0]]) atoms = atoms*[4, 4, 4] atoms.pbc = [True, True, True] def run(cutoff, atoms): kwargs = {'label': 'conv/cutoff/{0}/pt-{0}'.format(cutoff, cutoff), 'xc': 'PBE', 'scf_guess': 'atomic', 'max_scf': 500, 'EPS_SCF': 5.0E-7, 'added_mos': 500, 'sme/method': 'fermi_dirac', 'ELECTRONIC_TEMPERATURE': 300, 'DIA/ALGORITHM': 'STANDARD', 'mix/METHOD': 'BROYDEN_MIXING',
def graphene_nanoribbon( n, m, type="zigzag", saturated=False, C_H=1.09, C_C=1.42, vacuum=2.5, magnetic=None, initial_mag=1.12, sheet=False, main_element="C", saturate_element="H", vacc=None, ): """Create a graphene nanoribbon. Creates a graphene nanoribbon in the x-z plane, with the nanoribbon running along the z axis. Parameters: n: The width of the nanoribbon m: The length of the nanoribbon. type ('zigzag'): The orientation of the ribbon. Must be either 'zigzag' or 'armchair'. saturated (Falsi): If true, hydrogen atoms are placed along the edge. C_H: Carbon-hydrogen bond length. Default: 1.09 Angstrom C_C: Carbon-carbon bond length. Default: 1.42 Angstrom. vacuum: Amount of vacuum added to both sides. Default 2.5 Angstrom. magnetic: Make the edges magnetic. initial_mag: Magnitude of magnetic moment if magnetic=True. sheet: If true, make an infinite sheet instead of a ribbon. """ # This function creates the coordinates for a graphene nanoribbon, # n is width, m is length if vacc is not None: warnings.warn("Use vacuum=%f" % (0.5 * vacc)) vacuum = 0.5 * vacc assert vacuum > 0 b = sqrt(3) * C_C / 4 arm_unit = Atoms(main_element + "4", pbc=(1, 0, 1), cell=[4 * b, 2 * vacuum, 3 * C_C]) arm_unit.positions = [[0, 0, 0], [b * 2, 0, C_C / 2.0], [b * 2, 0, 3 * C_C / 2.0], [0, 0, 2 * C_C]] zz_unit = Atoms(main_element + "2", pbc=(1, 0, 1), cell=[3 * C_C / 2.0, 2 * vacuum, b * 4]) zz_unit.positions = [[0, 0, 0], [C_C / 2.0, 0, b * 2]] atoms = Atoms() tol = 1e-4 if sheet: vacuum2 = 0.0 else: vacuum2 = vacuum if type == "zigzag": edge_index0 = np.arange(m) * 2 + 1 edge_index1 = (n - 1) * m * 2 + np.arange(m) * 2 if magnetic: mms = np.zeros(m * n * 2) for i in edge_index0: mms[i] = initial_mag for i in edge_index1: mms[i] = -initial_mag for i in range(n): layer = zz_unit.repeat((1, 1, m)) layer.positions[:, 0] -= 3 * C_C / 2 * i if i % 2 == 1: layer.positions[:, 2] += 2 * b layer[-1].position[2] -= b * 4 * m atoms += layer if magnetic: atoms.set_initial_magnetic_moments(mms) if saturated: H_atoms0 = Atoms(saturate_element + str(m)) H_atoms0.positions = atoms[edge_index0].positions H_atoms0.positions[:, 0] += C_H H_atoms1 = Atoms(saturate_element + str(m)) H_atoms1.positions = atoms[edge_index1].positions H_atoms1.positions[:, 0] -= C_H atoms += H_atoms0 + H_atoms1 atoms.cell = [n * 3 * C_C / 2 + 2 * vacuum2, 2 * vacuum, m * 4 * b] elif type == "armchair": for i in range(n): layer = arm_unit.repeat((1, 1, m)) layer.positions[:, 0] -= 4 * b * i atoms += layer atoms.cell = [b * 4 * n + 2 * vacuum2, 2 * vacuum, 3 * C_C * m] atoms.center() atoms.set_pbc([sheet, False, True]) return atoms
def graphene_nanoribbon(n, m, type='zigzag', saturated=False, C_H=1.09, C_C=1.42, vacuum=2.5, magnetic=None, initial_mag=1.12, sheet=False, main_element='C', saturate_element='H', vacc=None): """Create a graphene nanoribbon. Creates a graphene nanoribbon in the x-z plane, with the nanoribbon running along the z axis. Parameters: n: int The width of the nanoribbon. m: int The length of the nanoribbon. type: str The orientation of the ribbon. Must be either 'zigzag' or 'armchair'. saturated: bool If true, hydrogen atoms are placed along the edge. C_H: float Carbon-hydrogen bond length. Default: 1.09 Angstrom. C_C: float Carbon-carbon bond length. Default: 1.42 Angstrom. vacuum: float Amount of vacuum added to both sides. Default 2.5 Angstrom. magnetic: bool Make the edges magnetic. initial_mag: float Magnitude of magnetic moment if magnetic=True. sheet: bool If true, make an infinite sheet instead of a ribbon. """ if vacc is not None: warnings.warn('Use vacuum=%f' % (0.5 * vacc)) vacuum = 0.5 * vacc assert vacuum > 0 b = sqrt(3) * C_C / 4 arm_unit = Atoms(main_element + '4', pbc=(1, 0, 1), cell=[4 * b, 2 * vacuum, 3 * C_C]) arm_unit.positions = [[0, 0, 0], [b * 2, 0, C_C / 2.], [b * 2, 0, 3 * C_C / 2.], [0, 0, 2 * C_C]] zz_unit = Atoms(main_element + '2', pbc=(1, 0, 1), cell=[3 * C_C / 2.0, 2 * vacuum, b * 4]) zz_unit.positions = [[0, 0, 0], [C_C / 2.0, 0, b * 2]] atoms = Atoms() if sheet: vacuum2 = 0.0 else: vacuum2 = vacuum if type == 'zigzag': edge_index0 = np.arange(m) * 2 + 1 edge_index1 = (n - 1) * m * 2 + np.arange(m) * 2 if magnetic: mms = np.zeros(m * n * 2) for i in edge_index0: mms[i] = initial_mag for i in edge_index1: mms[i] = -initial_mag for i in range(n): layer = zz_unit.repeat((1, 1, m)) layer.positions[:, 0] -= 3 * C_C / 2 * i if i % 2 == 1: layer.positions[:, 2] += 2 * b layer[-1].position[2] -= b * 4 * m atoms += layer if magnetic: atoms.set_initial_magnetic_moments(mms) if saturated: H_atoms0 = Atoms(saturate_element + str(m)) H_atoms0.positions = atoms[edge_index0].positions H_atoms0.positions[:, 0] += C_H H_atoms1 = Atoms(saturate_element + str(m)) H_atoms1.positions = atoms[edge_index1].positions H_atoms1.positions[:, 0] -= C_H atoms += H_atoms0 + H_atoms1 atoms.cell = [n * 3 * C_C / 2 + 2 * vacuum2, 2 * vacuum, m * 4 * b] elif type == 'armchair': for i in range(n): layer = arm_unit.repeat((1, 1, m)) layer.positions[:, 0] -= 4 * b * i atoms += layer if saturated: arm_right_saturation = Atoms(saturate_element + '2', pbc=(1, 0, 1), cell=[4 * b, 2 * vacuum, 3 * C_C]) arm_right_saturation.positions = [ [- sqrt(3) / 2 * C_H, 0, C_H * 0.5], [- sqrt(3) / 2 * C_H, 0, 2 * C_C - C_H * 0.5]] arm_left_saturation = Atoms(saturate_element + '2', pbc=(1, 0, 1), cell=[4 * b, 2 * vacuum, 3 * C_C]) arm_left_saturation.positions = [ [b * 2 + sqrt(3) / 2 * C_H, 0, C_C / 2 - C_H * 0.5], [b * 2 + sqrt(3) / 2 * C_H, 0, 3 * C_C / 2.0 + C_H * 0.5]] arm_right_saturation.positions[:, 0] -= 4 * b * (n - 1) atoms += arm_right_saturation.repeat((1, 1, m)) atoms += arm_left_saturation.repeat((1, 1, m)) atoms.cell = [b * 4 * n + 2 * vacuum2, 2 * vacuum, 3 * C_C * m] atoms.center() atoms.set_pbc([sheet, False, True]) return atoms
def read_gromacs(filename): """ From: http://manual.gromacs.org/current/online/gro.html C format "%5d%-5s%5s%5d%8.3f%8.3f%8.3f%8.4f%8.4f%8.4f" python: starting from 0, including first excluding last 0:4 5:10 10:15 15:20 20:28 28:36 36:44 44:52 52:60 60:68 Import gromacs geometry type files (.gro). Reads atom positions, velocities(if present) and simulation cell (if present) """ atoms = Atoms() filed = open(filename, 'r') lines = filed.readlines() filed.close() positions = [] gromacs_velocities = [] symbols = [] tags = [] gromacs_residuenumbers = [] gromacs_residuenames = [] gromacs_atomtypes = [] sym2tag = {} tag = 0 for line in (lines[2:-1]): # print(line[0:5]+':'+line[5:11]+':'+line[11:15]+':'+line[15:20]) # it is not a good idea to use the split method with gromacs input # since the fields are defined by a fixed column number. Therefore, # they may not be space between the fields # inp = line.split() floatvect = float(line[20:28]) * 10.0, \ float(line[28:36]) * 10.0, \ float(line[36:44]) * 10.0 positions.append(floatvect) # read velocities velocities = np.array([0.0, 0.0, 0.0]) vx = line[44:52].strip() vy = line[52:60].strip() vz = line[60:68].strip() for iv, vxyz in enumerate([vx, vy, vz]): if len(vxyz) > 0: try: velocities[iv] = float(vxyz) except ValueError: raise ValueError("can not convert velocity to float") else: velocities = None if velocities is not None: # velocities from nm/ps to ase units velocities *= units.nm / (1000.0 * units.fs) gromacs_velocities.append(velocities) gromacs_residuenumbers.append(int(line[0:5])) gromacs_residuenames.append(line[5:11].strip()) symbol_read = line[11:16].strip()[0:2] if symbol_read not in sym2tag.keys(): sym2tag[symbol_read] = tag tag += 1 tags.append(sym2tag[symbol_read]) if symbol_read in atomic_numbers: symbols.append(symbol_read) elif symbol_read[0] in atomic_numbers: symbols.append(symbol_read[0]) elif symbol_read[-1] in atomic_numbers: symbols.append(symbol_read[-1]) else: # not an atomic symbol # if we can not determine the symbol, we use # the dummy symbol X symbols.append("X") gromacs_atomtypes.append(line[11:16].strip()) line = lines[-1] atoms = Atoms(symbols, positions, tags=tags) if len(gromacs_velocities) == len(atoms): atoms.set_velocities(gromacs_velocities) elif len(gromacs_velocities) != 0: raise ValueError("Some atoms velocities were not specified!") if not atoms.has('residuenumbers'): atoms.new_array('residuenumbers', gromacs_residuenumbers, int) atoms.set_array('residuenumbers', gromacs_residuenumbers, int) if not atoms.has('residuenames'): atoms.new_array('residuenames', gromacs_residuenames, str) atoms.set_array('residuenames', gromacs_residuenames, str) if not atoms.has('atomtypes'): atoms.new_array('atomtypes', gromacs_atomtypes, str) atoms.set_array('atomtypes', gromacs_atomtypes, str) # determine PBC and unit cell atoms.pbc = False inp = lines[-1].split() try: grocell = list(map(float, inp)) except ValueError: return atoms if len(grocell) < 3: return atoms cell = np.diag(grocell[:3]) if len(grocell) >= 9: cell.flat[[1, 2, 3, 5, 6, 7]] = grocell[3:9] atoms.cell = cell * 10. atoms.pbc = True return atoms
def parse_MD(label, write_traj=False, pbc=False, cell=None, chemical_symbols=[]): f = open(label + '.aimd') #f = open(label + '.restart') text = f.read() if text == '': return None # Parse out the steps steps = text.split(':MDSTEP:')[1:] if write_traj == False: steps = [steps[-1]] else: traj = Trajectory(label + '.traj', mode='w') # Parse out the energies n_images = len(steps) s = os.popen('grep ":FEN:" ' + label + '.aimd') engs = s.readlines()[-n_images:] engs = [float(a.split()[-1]) * Hartree for a in engs] s.close() # build a traj file out of the steps for j, step in enumerate(steps): # Find Indicies colons = step.split(':') #pos_index = colons.index('R(Bohr)') + 1 #frc_index = colons.index('F(Ha/Bohr)') + 1 #vel_index = colons.index('V(Bohr/atu)') + 1 pos_index = colons.index('R') + 1 frc_index = colons.index('F') + 1 vel_index = colons.index('V') + 1 # Parse the text positions = colons[pos_index].strip().split('\n') forces = colons[frc_index].strip().split('\n') velocities = colons[vel_index].strip().split('\n') # Initialize the arrays frc = np.empty((len(forces), 3)) vel = np.empty((len(velocities), 3)) stress = np.zeros((3, 3)) atoms = Atoms() for i, f, v in zip(range(len(forces)), forces, velocities): frc[i, :] = [float(a) * Hartree / Bohr for a in f.split()] vel[i, :] = [float(a) / Bohr / fs for a in v.split()] atoms += Atom(chemical_symbols[i], [float(a) * Bohr for a in positions[i].split()]) if 'STRESS' in step: stress_index = colons.index('STRESS_TOT(GPa)') + 1 for i, s in enumerate(colons[stress_index].strip().split('\n')): stress[i, :] = [float(a) * GPa for a in s.split()] atoms.set_velocities(vel) atoms.set_pbc(pbc) atoms.cell = cell atoms.set_calculator( SinglePointCalculator(atoms, energy=engs[j] * len(atoms), stress=stress, forces=frc)) if write_traj == True: traj.write(atoms) atoms.set_calculator() return atoms
#!/usr/bin/env python from xcp2k import CP2K from ase.atoms import Atom, Atoms from ase.lattice import bulk import numpy as np from multiprocessing import Pool, Process import os from ase.eos import EquationOfState import time atoms = Atoms([Atom('Pt', (0.0, 0.0, 0.0)), Atom('Pt', (2.0, 2.0, 0.0)), Atom('Pt', (2.0, 0.0, 2.0)), Atom('Pt', (0.0, 2.0, 2.0))]) atoms.cell= 4.0 * np.array([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]) atoms = atoms*[1, 1, 1] atoms.pbc = [True, True, True] kwargs = {'label': 'relax/111/relax', 'xc': 'PBE', 'scf_guess': 'atomic', 'max_scf': 500, 'EPS_SCF': 5.0E-7, 'added_mos': 500, 'sme/method': 'fermi_dirac', 'ELECTRONIC_TEMPERATURE': 300,
def graphene_nanoribbon(n, m, type='zigzag', saturated=False, C_H=1.09, C_C=1.42, vacuum=2.5, magnetic=None, initial_mag=1.12, sheet=False, main_element='C', saturate_element='H', vacc=None): """Create a graphene nanoribbon. Creates a graphene nanoribbon in the x-z plane, with the nanoribbon running along the z axis. Parameters: n: The width of the nanoribbon m: The length of the nanoribbon. type ('zigzag'): The orientation of the ribbon. Must be either 'zigzag' or 'armchair'. saturated (Falsi): If true, hydrogen atoms are placed along the edge. C_H: Carbon-hydrogen bond length. Default: 1.09 Angstrom C_C: Carbon-carbon bond length. Default: 1.42 Angstrom. vacuum: Amount of vacuum added to both sides. Default 2.5 Angstrom. magnetic: Make the edges magnetic. initial_mag: Magnitude of magnetic moment if magnetic=True. sheet: If true, make an infinite sheet instead of a ribbon. """ #This function creates the coordinates for a graphene nanoribbon, #n is width, m is length if vacc is not None: warnings.warn('Use vacuum=%f' % (0.5 * vacc)) vacuum = 0.5 * vacc assert vacuum > 0 b = sqrt(3) * C_C / 4 arm_unit = Atoms(main_element + '4', pbc=(1, 0, 1), cell=[4 * b, 2 * vacuum, 3 * C_C]) arm_unit.positions = [[0, 0, 0], [b * 2, 0, C_C / 2.], [b * 2, 0, 3 * C_C / 2.], [0, 0, 2 * C_C]] zz_unit = Atoms(main_element + '2', pbc=(1, 0, 1), cell=[3 * C_C / 2., 2 * vacuum, b * 4]) zz_unit.positions = [[0, 0, 0], [C_C / 2., 0, b * 2]] atoms = Atoms() tol = 1e-4 if sheet: vacuum2 = 0.0 else: vacuum2 = vacuum if type == 'zigzag': edge_index0 = np.arange(m) * 2 + 1 edge_index1 = (n - 1) * m * 2 + np.arange(m) * 2 if magnetic: mms = np.zeros(m * n * 2) for i in edge_index0: mms[i] = initial_mag for i in edge_index1: mms[i] = -initial_mag for i in range(n): layer = zz_unit.repeat((1, 1, m)) layer.positions[:, 0] -= 3 * C_C / 2 * i if i % 2 == 1: layer.positions[:, 2] += 2 * b layer[-1].position[2] -= b * 4 * m atoms += layer if magnetic: atoms.set_initial_magnetic_moments(mms) if saturated: H_atoms0 = Atoms(saturate_element + str(m)) H_atoms0.positions = atoms[edge_index0].positions H_atoms0.positions[:, 0] += C_H H_atoms1 = Atoms(saturate_element + str(m)) H_atoms1.positions = atoms[edge_index1].positions H_atoms1.positions[:, 0] -= C_H atoms += H_atoms0 + H_atoms1 atoms.cell = [n * 3 * C_C / 2 + 2 * vacuum2, 2 * vacuum, m * 4 * b] elif type == 'armchair': for i in range(n): layer = arm_unit.repeat((1, 1, m)) layer.positions[:, 0] -= 4 * b * i atoms += layer atoms.cell = [b * 4 * n + 2 * vacuum2, 2 * vacuum, 3 * C_C * m] atoms.center() atoms.set_pbc([sheet, False, True]) return atoms