Example #1
0
def parse_set_of_forces(num_atoms, forces_filenames, verbose=True):
    """Parse forces from output files."""
    hook = "1 #"
    is_parsed = True
    force_sets = []

    for i, filename in enumerate(forces_filenames):
        if verbose:
            sys.stdout.write("%d. " % (i + 1))
        f = open(filename)
        fleur_forces = collect_forces(f,
                                      num_atoms,
                                      hook, [0, 1, 2],
                                      word="force")
        if check_forces(fleur_forces, num_atoms, filename, verbose=verbose):
            drift_force = get_drift_forces(fleur_forces,
                                           filename=filename,
                                           verbose=verbose)
            force_sets.append(np.array(fleur_forces) - drift_force)
        else:
            is_parsed = False

    if is_parsed:
        return force_sets
    else:
        return []
Example #2
0
def parse_set_of_forces(num_atoms,
                        forces_filenames,
                        verbose=True):
    hook = 'Forces acting on atoms'
    is_parsed = True
    force_sets = []

    for i, filename in enumerate(forces_filenames):
        if verbose:
            sys.stdout.write("%d. " % (i + 1))
        pwscf_forces = iter_collect_forces(filename,
                                           num_atoms,
                                           hook,
                                           [6, 7, 8],
                                           word='force')
        if check_forces(pwscf_forces, num_atoms, filename, verbose=verbose):
            drift_force = get_drift_forces(pwscf_forces,
                                           filename=filename,
                                           verbose=verbose)
            force_sets.append(np.array(pwscf_forces) - drift_force)
        else:
            is_parsed = False

    if is_parsed:
        return force_sets
    else:
        return []
Example #3
0
def parse_set_of_forces(disps, forces_filenames, supercell, is_distribute=True, symprec=1e-5, verbose=True):
    num_atoms = supercell.get_number_of_atoms()
    lattice = supercell.get_cell()
    is_parsed = True
    force_sets = []

    for i, (filename, disp) in enumerate(zip(forces_filenames, disps)):
        if verbose:
            sys.stdout.write("%d. " % (i + 1))

        # Parse wien2k case.scf file
        wien2k_forces = _get_forces_wien2k(filename, lattice)
        if is_distribute:
            forces = _distribute_forces(supercell, disp, wien2k_forces, filename, symprec)
        else:
            if num_atoms != len(wien2k_forces):
                forces = []
            else:
                forces = wien2k_forces

        if check_forces(forces, num_atoms, filename, verbose=verbose):
            drift_force = get_drift_forces(forces, filename=filename, verbose=verbose)
            force_sets.append(np.array(forces) - drift_force)
        else:
            is_parsed = False

    if is_parsed:
        return force_sets
    else:
        return []
Example #4
0
def parse_set_of_forces(num_atoms, forces_filenames, verbose=True):
    hook = 'Cartesian components (eV/A)'
    skipafterhook = 3
    is_parsed = True
    force_sets = []
    for i, filename in enumerate(forces_filenames):
        if verbose:
            sys.stdout.write("%d. " % (i + 1))

        f = open(filename)
        castep_forces = collect_forces_castep(f,
                                              num_atoms,
                                              hook, [3, 4, 5],
                                              skipafterhook=3)

        if check_forces(castep_forces, num_atoms, filename, verbose=verbose):
            drift_force = get_drift_forces(castep_forces,
                                           filename=filename,
                                           verbose=verbose)
            force_sets.append(np.array(castep_forces) - drift_force)
        else:
            is_parsed = False

    if is_parsed:
        return force_sets
    else:
        return []
Example #5
0
File: elk.py Project: gcgs1/phonopy
def parse_set_of_forces(num_atoms, forces_filenames, verbose=True):
    hook = 'Forces :'
    is_parsed = True
    force_sets = []

    for i, filename in enumerate(forces_filenames):
        if verbose:
            sys.stdout.write("%d. " % (i + 1))
        f = open(filename)
        elk_forces = collect_forces(f,
                                    num_atoms,
                                    hook,
                                    [3, 4, 5],
                                    word='total force')
        if check_forces(elk_forces, num_atoms, filename, verbose=verbose):
            drift_force = get_drift_forces(elk_forces,
                                           filename=filename,
                                           verbose=verbose)
            force_sets.append(np.array(elk_forces) - drift_force)
        else:
            is_parsed = False

    if is_parsed:
        return force_sets
    else:
        return []
Example #6
0
def parse_set_of_forces(num_atoms,
                        forces_filenames,
                        verbose=True):
    hook = 'ATOM                     X                   Y                   Z'
    force_sets = []
    for i, filename in enumerate(forces_filenames):
        if verbose:
            sys.stdout.write("%d. " % (i + 1))
        crystal_forces = iter_collect_forces(filename,
                                           num_atoms,
                                           hook,
                                           [2, 3, 4])
        if check_forces(crystal_forces, num_atoms, filename, verbose=verbose):
            is_parsed = True
            drift_force = get_drift_forces(crystal_forces,
                                           filename=filename,
                                           verbose=verbose)
            # Convert forces Hartree / Bohr ->  eV / Angstrom
            # This avoids confusion with the units. CRYSTAL uses Angstroms for
            # coordinates, but Hartree / Bohr for forces. This would lead in mixed
            # units hartree / (Angstrom * Bohr) for force constants, requiring
            # additional tweaks for unit conversions in other parts of the code
            force_sets.append(np.multiply(np.array(crystal_forces) - drift_force, Hartree / Bohr))
        else:
            is_parsed = False

    if is_parsed:
        return force_sets
    else:
        return []
Example #7
0
def parse_set_of_forces(num_atoms, forces_filenames, verbose=True):
    hook = 'Forces :'
    is_parsed = True
    force_sets = []

    for i, filename in enumerate(forces_filenames):
        if verbose:
            sys.stdout.write("%d. " % (i + 1))
        f = open(filename)
        elk_forces = collect_forces(f,
                                    num_atoms,
                                    hook, [3, 4, 5],
                                    word='total force')
        if check_forces(elk_forces, num_atoms, filename, verbose=verbose):
            drift_force = get_drift_forces(elk_forces,
                                           filename=filename,
                                           verbose=verbose)
            force_sets.append(np.array(elk_forces) - drift_force)
        else:
            is_parsed = False

    if is_parsed:
        return force_sets
    else:
        return []
Example #8
0
def parse_set_of_forces(num_atoms, forces_filenames, verbose=True):
    hook = 'ATOM                     X                   Y                   Z'
    force_sets = []
    for i, filename in enumerate(forces_filenames):
        if verbose:
            sys.stdout.write("%d. " % (i + 1))
        crystal_forces = iter_collect_forces(filename, num_atoms, hook,
                                             [2, 3, 4])
        if check_forces(crystal_forces, num_atoms, filename, verbose=verbose):
            is_parsed = True
            drift_force = get_drift_forces(crystal_forces,
                                           filename=filename,
                                           verbose=verbose)
            # Convert forces Hartree / Bohr ->  eV / Angstrom
            # This avoids confusion with the units. CRYSTAL uses Angstroms for
            # coordinates, but Hartree / Bohr for forces. This would lead in mixed
            # units hartree / (Angstrom * Bohr) for force constants, requiring
            # additional tweaks for unit conversions in other parts of the code
            force_sets.append(
                np.multiply(
                    np.array(crystal_forces) - drift_force, Hartree / Bohr))
        else:
            is_parsed = False

    if is_parsed:
        return force_sets
    else:
        return []
Example #9
0
def parse_set_of_forces(num_atoms, forces_filenames, verbose=False):
    hook = 'CONVERGED'
    force_sets = []
    for fplo_filename in forces_filenames:
        fplo_forces = iter_collect_forces(fplo_filename,
                                          num_atoms,
                                          hook, [6, 7, 8],
                                          word='TOTAL NEUTRAL FORCES')

        # rotate forces from the FPLO xyz coordinate system
        # into the coordinate system of phonopy

        # read the phonopy lattice vectors
        conf, cell = parse_disp_yaml(return_cell=True)
        ppy_lat = cell.get_cell()

        # read the fplo output file
        f = open(fplo_filename, 'r')
        outf = f.readlines()
        f.close

        # search lattice vectors
        fp_lat = np.zeros((3, 3))
        for j in np.arange(len(outf)):
            if outf[j].find("lattice vectors") == 0:
                for i in np.arange(3):
                    fp_lat[i, :] = list(
                        map(float,
                            outf[j + i + 1].split(":")[1].split()))  # [bohr]

        if np.allclose(fp_lat, np.zeros((3, 3))):
            sys.exit("(EE) The lattice vectors were not found in: " +
                     fplo_filename)

        T = np.dot(np.linalg.inv(ppy_lat), fp_lat)

        if not np.allclose(np.dot(T.T, T), np.eye(3)):
            sys.exit("(EE) The basis transformation is wrong!")

        for i in np.arange(len(fplo_forces)):
            fplo_forces[i] = np.dot(T, np.array(fplo_forces[i]))

        # Calculate the drift_force (sum over all forces has to be zero) and
        # normalize the forces.
        drift_force = get_drift_forces(fplo_forces, fplo_filename, verbose)
        force_sets.append(np.array(fplo_forces) - drift_force)

    return force_sets
Example #10
0
def parse_set_of_forces(
    disps,
    forces_filenames,
    supercell,
    wien2k_P1_mode=False,  # Only for the test
    symmetry_tolerance=None,
    verbose=True,
):
    """Parse forces from output files."""
    if symmetry_tolerance is None:
        symprec = 1e-5
    else:
        symprec = symmetry_tolerance

    num_atoms = supercell.get_number_of_atoms()
    lattice = supercell.get_cell()
    is_parsed = True
    force_sets = []

    for i, (filename, disp) in enumerate(zip(forces_filenames, disps)):
        if verbose:
            sys.stdout.write("%d. " % (i + 1))

        # Parse wien2k case.scf file
        wien2k_forces = _get_forces_wien2k(filename, lattice)
        if not wien2k_P1_mode:
            forces = _distribute_forces(supercell, disp, wien2k_forces,
                                        filename, symprec)
        else:
            if num_atoms != len(wien2k_forces):
                forces = []
            else:
                forces = wien2k_forces

        if check_forces(forces, num_atoms, filename, verbose=verbose):
            drift_force = get_drift_forces(forces,
                                           filename=filename,
                                           verbose=verbose)
            force_sets.append(np.array(forces) - drift_force)
        else:
            is_parsed = False

    if is_parsed:
        return force_sets
    else:
        return []
Example #11
0
def parse_set_of_forces(num_atoms, forces_filenames, verbose=True):
    force_sets = []

    for i, filename in enumerate(forces_filenames):
        if verbose:
            sys.stdout.write("%d. " % (i + 1))

        forces = iter_collect_forces(filename, num_atoms,
                                     '# Atom   Kind   Element', [3, 4, 5])

        if not check_forces(forces, num_atoms, filename, verbose=verbose):
            return []  # if one file is invalid, the whole thing is broken

        drift_force = get_drift_forces(forces,
                                       filename=filename,
                                       verbose=verbose)
        force_sets.append(np.array(forces) - drift_force)

    return force_sets
Example #12
0
def parse_set_of_forces(disps,
                        forces_filenames,
                        supercell,
                        is_distribute=True,
                        symprec=1e-5,
                        verbose=True):
    num_atoms = supercell.get_number_of_atoms()
    lattice = supercell.get_cell()
    is_parsed = True
    force_sets = []

    for i, (filename, disp) in enumerate(zip(forces_filenames, disps)):
        if verbose:
            sys.stdout.write("%d. " % (i + 1))

        # Parse wien2k case.scf file
        wien2k_forces = _get_forces_wien2k(filename, lattice)
        if is_distribute:
            forces = _distribute_forces(
                supercell,
                disp,
                wien2k_forces,
                filename,
                symprec)
        else:
            if num_atoms != len(wien2k_forces):
                forces = []
            else:
                forces = wien2k_forces

        if check_forces(forces, num_atoms, filename, verbose=verbose):
            drift_force = get_drift_forces(forces,
                                           filename=filename,
                                           verbose=verbose)
            force_sets.append(np.array(forces) - drift_force)
        else:
            is_parsed = False

    if is_parsed:
        return force_sets
    else:
        return []
Example #13
0
def parse_set_of_forces(num_atoms, forces_filenames, verbose=True):
    is_parsed = True
    force_sets = []
    for i, filename in enumerate(forces_filenames):
        if verbose:
            sys.stdout.write("%d. " % (i + 1))
        lmto_forces = np.loadtxt(filename, dtype=float, skiprows=1)

        if check_forces(lmto_forces, num_atoms, filename, verbose=verbose):
            drift_force = get_drift_forces(lmto_forces,
                                           filename=filename,
                                           verbose=verbose)
            force_sets.append(lmto_forces - drift_force)
        else:
            is_parsed = False

    if is_parsed:
        return force_sets
    else:
        return []
Example #14
0
def parse_set_of_forces(num_atoms, forces_filenames, verbose=True):
    is_parsed = True
    force_sets = []
    for i, filename in enumerate(forces_filenames):
        if verbose:
            sys.stdout.write("%d. " % (i + 1))
        lmto_forces = np.loadtxt(filename, dtype=float, skiprows=1)

        if check_forces(lmto_forces, num_atoms, filename, verbose=verbose):
            drift_force = get_drift_forces(lmto_forces,
                                               filename=filename,
                                               verbose=verbose)
            force_sets.append(lmto_forces - drift_force)
        else:
            is_parsed = False

    if is_parsed:
        return force_sets
    else:
        return []
Example #15
0
def parse_set_of_forces(num_atoms, forces_filenames, verbose=True):
    hook = '# Atom   Kind   Element'

    force_sets = []

    for i, filename in enumerate(forces_filenames):
        if verbose:
            sys.stdout.write("%d. " % (i + 1))

        with open(filename) as fhandle:
            cp2k_forces = collect_forces(fhandle, num_atoms, hook, [3, 4, 5])
            if check_forces(cp2k_forces, num_atoms, filename, verbose=verbose):
                drift_force = get_drift_forces(cp2k_forces,
                                               filename=filename,
                                               verbose=verbose)
                force_sets.append(np.array(cp2k_forces) - drift_force)
            else:
                return []  # if one file is invalid, the whole thing is broken

    return force_sets
Example #16
0
def parse_set_of_forces(num_atoms, forces_filenames, verbose=True):
    # Filenames = subdirectories supercell-001, supercell-002, ...
    force_sets = []
    for i, filename in enumerate(forces_filenames):
        if verbose:
            sys.stdout.write("%d. " % (i + 1))

        f_gradient = open(os.path.join(filename, 'gradient'))
        lines = f_gradient.readlines()
        f_gradient.close()
        # Structure of the gradient file:
        #$grad          cartesian gradients
        #  cycle =      1    SCF energy =     -578.5931883878   |dE/dxyz| =  0.000007
        # coordinates (num_atoms lines)
        # gradients (num_atoms lines)
        #$end
        turbomole_forces = []
        for line in lines[2 + num_atoms:2 + 2 * num_atoms]:
            # Replace D with E in double precision floats
            turbomole_forces.append(
                [float(x.replace('D', 'E')) for x in line.split()])

        # Change from gradient to force by inverting the sign
        # Units: hartree / Bohr
        turbomole_forces = np.negative(turbomole_forces)

        if check_forces(turbomole_forces, num_atoms, filename,
                        verbose=verbose):
            is_parsed = True
            drift_force = get_drift_forces(turbomole_forces,
                                           filename=filename,
                                           verbose=verbose)
            force_sets.append(np.array(turbomole_forces) - drift_force)
        else:
            is_parsed = False

    if is_parsed:
        return force_sets
    else:
        return []
Example #17
0
def parse_set_of_forces(num_atoms,
                        forces_filenames,
                        verbose=True):
    # Filenames = subdirectories supercell-001, supercell-002, ...
    force_sets = []
    for i, filename in enumerate(forces_filenames):
        if verbose:
            sys.stdout.write("%d. " % (i + 1))

        f_gradient = open(os.path.join(filename, 'gradient'))
        lines = f_gradient.readlines()
        f_gradient.close()
        # Structure of the gradient file:
        #$grad          cartesian gradients
        #  cycle =      1    SCF energy =     -578.5931883878   |dE/dxyz| =  0.000007
        # coordinates (num_atoms lines)
        # gradients (num_atoms lines)
        #$end
        turbomole_forces = []
        for line in lines[2 + num_atoms : 2 + 2 * num_atoms]:
            # Replace D with E in double precision floats
            turbomole_forces.append([float(x.replace('D', 'E')) for x in line.split()])

        # Change from gradient to force by inverting the sign
        # Units: hartree / Bohr
        turbomole_forces = np.negative(turbomole_forces)

        if check_forces(turbomole_forces, num_atoms, filename, verbose=verbose):
            is_parsed = True
            drift_force = get_drift_forces(turbomole_forces,
                                           filename=filename,
                                           verbose=verbose)
            force_sets.append(np.array(turbomole_forces) - drift_force)
        else:
            is_parsed = False

    if is_parsed:
        return force_sets
    else:
        return []
Example #18
0
def parse_set_of_forces(num_atoms, forces_filenames, verbose=True):
    hook = 'cartesian forces (eV/Angstrom)'
    is_parsed = True
    force_sets = []
    for i, filename in enumerate(forces_filenames):
        if verbose:
            sys.stdout.write("%d. " % (i + 1))

        f = open(filename)
        abinit_forces = collect_forces(f, num_atoms, hook, [1, 2, 3])
        if check_forces(abinit_forces, num_atoms, filename, verbose=verbose):
            drift_force = get_drift_forces(abinit_forces,
                                           filename=filename,
                                           verbose=verbose)
            force_sets.append(np.array(abinit_forces) - drift_force)
        else:
            is_parsed = False

    if is_parsed:
        return force_sets
    else:
        return []
Example #19
0
def parse_set_of_forces(num_atoms, forces_filenames, verbose=True):
    """Parse the forces from output files in ``forces_filenames``."""
    is_parsed = True
    force_sets = []
    for i, filename in enumerate(forces_filenames):
        if verbose:
            sys.stdout.write("%d. " % (i + 1))

        atoms = read_aims_output(filename)
        forces = atoms.forces
        if check_forces(forces, num_atoms, filename, verbose=verbose):
            drift_force = get_drift_forces(forces,
                                           filename=filename,
                                           verbose=verbose)
            force_sets.append(np.array(forces) - drift_force)
        else:
            is_parsed = False

    if is_parsed:
        return force_sets
    else:
        return []
Example #20
0
def parse_set_of_forces(num_atoms, forces_filenames, verbose=True):
    hook = 'cartesian forces (eV/Angstrom)'
    is_parsed = True
    force_sets = []
    for i, filename in enumerate(forces_filenames):
        if verbose:
            sys.stdout.write("%d. " % (i + 1))

        f = open(filename)
        abinit_forces = collect_forces(f, num_atoms, hook, [1, 2, 3])
        if check_forces(abinit_forces, num_atoms, filename, verbose=verbose):
            drift_force = get_drift_forces(abinit_forces,
                                           filename=filename,
                                           verbose=verbose)
            force_sets.append(np.array(abinit_forces) - drift_force)
        else:
            is_parsed = False

    if is_parsed:
        return force_sets
    else:
        return []
Example #21
0
def parse_set_of_forces(num_atoms, forces_filenames, verbose=True):
    hook = ''  # Just for skipping the first line
    is_parsed = True
    force_sets = []
    for i, filename in enumerate(forces_filenames):
        if verbose:
            sys.stdout.write("%d. " % (i + 1))
        siesta_forces = iter_collect_forces(filename,
                                            num_atoms,
                                            hook, [1, 2, 3],
                                            word='')
        if check_forces(siesta_forces, num_atoms, filename, verbose=verbose):
            drift_force = get_drift_forces(siesta_forces,
                                           filename=filename,
                                           verbose=verbose)
            force_sets.append(np.array(siesta_forces) - drift_force)
        else:
            is_parsed = False

    if is_parsed:
        return force_sets
    else:
        return []
Example #22
0
def parse_set_of_forces(num_atoms, forces_filenames, verbose=True):
    hook = '' # Just for skipping the first line
    is_parsed = True
    force_sets = []
    for i, filename in enumerate(forces_filenames):
        if verbose:
            sys.stdout.write("%d. " % (i + 1))
        siesta_forces = iter_collect_forces(filename,
                                            num_atoms,
                                            hook,
                                            [1, 2, 3],
                                            word='')
        if check_forces(siesta_forces, num_atoms, filename, verbose=verbose):
            drift_force = get_drift_forces(siesta_forces,
                                           filename=filename,
                                           verbose=verbose)
            force_sets.append(np.array(siesta_forces) - drift_force)
        else:
            is_parsed = False

    if is_parsed:
        return force_sets
    else:
        return []