Example #1
0
    K.nspecies < 7)

n = len(results)  # number of avaiable data points

X_sp_metals = []
Y_sp_metals = []
materials_info = []

for i, result in enumerate(results):
    try:
        if result.catalog == 'ICSD\n':
            URL = result.files['DOSCAR.static.xz']
            save_xz(result.compound + '.xz', URL)

            # Construct RDF with POSCAR
            crystal = Structure.from_str(result.files['CONTCAR.relax.vasp'](),
                                         fmt='poscar')

            # Get elements in the compound
            elements = result.species
            last_element = elements[-1]
            last_element = last_element[:-1]
            elements[-1] = last_element

            # Collecting for sp_metals compound
            j = 0
            for element in elements:
                if element in sp_system:
                    j += 1
            if j == len(elements):
                X_sp_metals.append(RDF(crystal).RDF[1, :])
                dos = get_DOS_fermi(result.compound + '.txt', result)
Example #2
0
def test_check_points_3():
    settings = {
        'deformation_fraction': [-0.05, 0.05],
        'num_deformations': 3,
        'deformation_scheme': 'volume',
        'run_isif': 4,
        'phonon': True,
        'phonon_supercell_matrix': [[-2, 2, 2], [2, -2, 2], [2, 2, -2]],
        'override_default_vasp_params': {
            'user_incar_settings': {
                'EDIFF_PER_ATOM': 1e-07,
                'Relax_settings': {
                    'PREC': 'HIGH',
                    'grid_density': 1000
                },
                'Static_settings': {
                    'PREC': 'HIGH',
                    'grid_density': 1000
                }
            },
            'user_kpoints_settings': {
                'grid_density': 1000
            }
        },
        'metadata': {
            'tag': '67783198-6d5a-40c2-8d49-4f03e50ac130'
        }
    }

    ################ PARAMETERS FOR WF #############################
    #str, the absolute path of db.json file, e.g. /storage/home/mjl6505/atomate/config/db.json
    #  If None, it will use the configuration in fireworks
    #db_file = settings.get('db_file', DB_FILE)
    db_file = loadfn(config_to_dict()["FWORKER_LOC"])["env"]["db_file"]
    #str, the vasp command, if None then find in the FWorker configuration
    vasp_cmd = settings.get('vasp_cmd', VASP_CMD)
    #dict, metadata to be included, this parameter is useful for filter the data, e.g. metadata={"phase": "BCC_A2", "tag": "AFM"}
    metadata = settings.get('metadata', {})
    tag = metadata.get('tag', '{}'.format(str(uuid4())))
    metadata.update({'tag': tag})

    #list/tuple(min, max) or float(-max, max), the maximum amplitude of deformation, e.g. (-0.15, 0.15) means (0.95, 1.1) in volume
    deformation_fraction = settings.get('deformation_fraction', (-0.15, 0.20))
    #int, the number of initial deformations, e.g. 7
    num_deformations = settings.get('num_deformations', 8)
    if num_deformations == 1:
        deformation_fraction[1] = deformation_fraction[0]
    #bool, run phonon(True) or not(False)
    phonon = settings.get('phonon', False)
    #list(3x3), the supercell matrix for phonon, e.g. [[2.0, 0, 0], [0, 2.0, 0], [0, 0, 2.0]]
    phonon_supercell_matrix = settings.get('phonon_supercell_matrix', None)
    phonon_supercell_matrix_min = settings.get('phonon_supercell_matrix_min',
                                               None)
    phonon_supercell_matrix_max = settings.get('phonon_supercell_matrix_max',
                                               None)
    optimize_sc = settings.get('optimize_sc', False)
    #The tolerance for phonon stable
    stable_tor = settings.get('stable_tor', 0.01)
    #float, the mimimum of temperature in QHA process, e.g. 5
    t_min = settings.get('t_min', 5)
    #float, the maximum of temperature in QHA process, e.g. 2000
    t_max = settings.get('t_max', 2000)
    #float, the step of temperature in QHA process, e.g. 5
    t_step = settings.get('t_step', 5)
    #float, acceptable value for average RMS, recommend >= 0.005
    eos_tolerance = settings.get('eos_tolerance', 0.01)

    #Global settings for all vasp job, e.g.
    #override_default_vasp_params = {'user_incar_settings': {}, 'user_kpoints_settings': {}, 'user_potcar_functional': str}
    #If some value in 'user_incar_settings' is set to None, it will use vasp's default value
    override_default_vasp_params = settings.get('override_default_vasp_params',
                                                {})

    #dict, dict of class ModifyIncar with keywords in Workflow name. e.g.
    modify_incar_params = settings.get('modify_incar_params', {})

    #check if fworker_name is assigned
    powerups = settings.get('powerups', {})
    if len(powerups) > 0:
        if 'user_incar_settings' not in override_default_vasp_params:
            override_default_vasp_params.update({'user_incar_settings': {}})
        override_default_vasp_params['user_incar_settings'].update(
            {'powerups': powerups})
        modify_incar_params.update({'powerups': powerups})

    #dict, dict of class ModifyKpoints with keywords in Workflow name, similar with modify_incar_params
    modify_kpoints_params = settings.get('modify_kpoints_params', {})
    #bool, print(True) or not(False) some informations, used for debug
    verbose = settings.get('verbose', False)
    #Save the volume data or not ("chgcar", "aeccar0", "aeccar2", "elfcar", "locpot")
    store_volumetric_data = settings.get('store_volumetric_data', False)

    if phonon:
        if isinstance(phonon_supercell_matrix, str):
            if phonon_supercell_matrix == 'Yphon':
                phonon_supercell_matrix = supercell_scaling_by_Yphon(
                    structure, supercellsize=phonon_supercell_matrix_max)
            else:
                phonon_supercell_matrix = supercell_scaling_by_atom_lat_vol(
                    structure,
                    min_obj=phonon_supercell_matrix_min,
                    max_obj=phonon_supercell_matrix_max,
                    scale_object=phonon_supercell_matrix,
                    target_shape='sc',
                    lower_search_limit=-2,
                    upper_search_limit=2,
                    verbose=verbose,
                    sc_tolerance=1e-5,
                    optimize_sc=optimize_sc)

    _deformations = _get_deformations(deformation_fraction, num_deformations)
    if num_deformations > 1: vol_spacing = _deformations[1] - _deformations[0]
    else: vol_spacing = 0.05

    structure = Structure.from_str(POSCAR_STR, fmt='POSCAR')
    t_kwargs = {'t_min': t_min, 't_max': t_max, 't_step': t_step}
    common_kwargs = {
        'vasp_cmd': vasp_cmd,
        'db_file': db_file,
        "metadata": metadata,
        "tag": tag,
        'override_default_vasp_params': override_default_vasp_params
    }
    vasp_kwargs = {
        'modify_incar_params': modify_incar_params,
        'modify_kpoints_params': modify_kpoints_params
    }
    eos_kwargs = {
        'deformations': _deformations,
        'vol_spacing': vol_spacing,
        'eos_tolerance': eos_tolerance,
        'threshold': 14
    }
    a_kwargs = {
        "structure": structure,
        "settings": settings,
        "eos_kwargs": eos_kwargs,
        "static": True,
        "phonon": phonon,
        "phonon_supercell_matrix": phonon_supercell_matrix
    }

    proc = Crosscom_EVcheck_QHA(verbose=verbose,
                                stable_tor=stable_tor,
                                run_num=0,
                                store_volumetric_data=store_volumetric_data,
                                a_kwargs=a_kwargs,
                                **eos_kwargs,
                                **vasp_kwargs,
                                **t_kwargs,
                                **common_kwargs,
                                test=True)
    proc.run_task({})
    assert False
Example #3
0
def test_symmetrize_defect_structure_2():
    structure = Structure.from_str(fmt="POSCAR",
                                   input_string="""Mg48 N31
   1.00000000000000
    10.00    0.00    0.00
     0.00   10.00    0.00
     0.00    0.00   10.00
  N
    31
Direct
  0.9998735951099533  0.9999339271342436  0.9998810782738516
  0.4998325344890802  0.0000864604371742  0.0001093145892668
  0.9999579188430090  0.5001853666498661  0.0001277381372233
  0.2491639910909313  0.2182663238872422  0.4987861655656971
  0.2808293379596023  0.4991743721150215  0.7498359204125151
  0.5007987323114946  0.2498921962049820  0.2191539974347521
  0.2186260754052398  0.4998463318536253  0.2504951842089369
  0.5003683092799207  0.7505911171114192  0.2814698995089699
  0.7491029691281099  0.2824156531954642  0.4998653178588484
  0.2496769296641759  0.2810133141130393  0.0008972384265746
  0.2179934993920654  0.0013328906653882  0.7491830895564036
  0.9985995146190305  0.2494223137356002  0.2817274775328684
  0.2819549960242611  0.0002510594995684  0.2492863143591961
  0.9999066837513126  0.7494408251560003  0.2182162389686653
  0.7503446162775589  0.2186089947761758  0.0001821657373426
  0.5000178504783079  0.5000386610406409  0.9999895875233165
  0.4999380720704565  0.5002342427150381  0.5000689317878368
  0.0000976472392296  0.5000243131273407  0.5000777225283457
  0.5001616481443207  0.0002089601314523  0.4998675396277079
  0.7502599885437249  0.7191435719333086  0.9992528941462950
  0.7820064323950149  0.9990033992670391  0.2509026823008185
  0.0012722293791043  0.7506950871201497  0.7182763220765622
  0.7176368346430237  0.9998582962107960  0.7509680009789932
  0.0000228430868177  0.2509182464808006  0.7821761073165092
  0.2495215811710665  0.7814963684974714  0.9998566240987685
  0.7508300518084354  0.7818602560717594  0.5013867902350881
  0.7190618878688895  0.5010405127949369  0.2502514755283229
  0.4989978969018409  0.7502977850544852  0.7809492219327865
  0.7814464623477875  0.5003886730650109  0.7494947707104060
  0.4996606931909255  0.2496508616713697  0.7186036919929819
  0.2506716727065808  0.7181216545822622  0.5001902272634595""")
    actual = refine_defect_structure(structure,
                                     anchor_atom_index=15,
                                     anchor_atom_coords=np.array(
                                         [0.5, 0.5, 0.0]))

    expected = Structure.from_str(fmt="POSCAR",
                                  input_string="""Mg4 O3
1.00000000000000
10 0 0
0 10 0
0 0 10
N
31
Direct
    0         0         0
    0.5       0         0
    0         0.5       0
    0.249164  0.218235  0.498835
    0.280829  0.499143  0.749885
    0.500857  0.249885  0.219171
    0.218626  0.499815  0.250544
    0.500185  0.750544  0.281374
    0.749103  0.282384  0.499914
    0.249885  0.280829  0.000857
    0.218235  0.001165  0.749164
    0.998835  0.249164  0.281765
    0.282384  8.6e-05   0.249103
    0.999914  0.749103  0.217616
    0.750544  0.218626  0.000185
    0.5       0.5       0
    0.5       0.5       0.5
    0         0.5       0.5
    0.5       1         0.5
    0.750115  0.719171  0.999143
    0.781765  0.998835  0.250836
    0.001165  0.750836  0.718235
    0.717616  0.999914  0.750897
    8.6e-05   0.250897  0.782384
    0.249456  0.781374  0.999815
    0.750836  0.781765  0.501165
    0.719171  0.500857  0.250115
    0.499143  0.750115  0.780829
    0.781374  0.500185  0.749456
    0.499815  0.249456  0.718626
    0.250897  0.717616  0.500086""")
    assert actual == expected
Example #4
0
# TODO: does not support use_fake_vasp yet. VASP will fail.

DEBUG_MODE = False

POSCAR_STR = """Si2
1.0
3.840198 0.000000 0.000000
1.920099 3.325710 0.000000
0.000000 -2.217138 3.135509
Si
2
direct
0.000000 0.000000 0.000000 Si
0.750000 0.500000 0.750000 Si"""
STRUCT = Structure.from_str(POSCAR_STR, fmt='POSCAR')
TEST_DIR = os.path.join(MODULE_DIR, 'tmp_fw_test_dir')
# LPAD = LaunchPad.from_dict({'host': 'localhost', 'logdir': None, 'name': 'dfttk_unittest', 'password': None, 'port': 27017, 'ssl_ca_file': None, 'strm_lvl': 'DEBUG', 'user_indices': [], 'username': None, 'wf_user_indices': []})

# TODO: enable debug mode by having a launchpad that does not reset
# Can this be done by still having other tests pass?
# Should we only run one test?
# Stop on failure?
@pytest.fixture
def lpad():
    """A LaunchPad object for test instances to use. Always gives a clean (reset) LaunchPad. """
    LPAD.reset(None, require_password=False, max_reset_wo_password=5)
    yield LPAD
    LPAD.connection.close()
    return
Example #5
0
    def add_structure(self, source, name=None, identifier=None, fmt=None):
        """add a structure to the mpfile"""
        from pymatgen.core import Structure
        from pymatgen.ext.matproj import MPRester

        if isinstance(source, Structure):
            structure = source
        elif isinstance(source, dict):
            structure = Structure.from_dict(source)
        elif os.path.exists(source):
            structure = Structure.from_file(source, sort=True)
        elif isinstance(source, six.string_types):
            if fmt is None:
                raise ValueError("Need fmt to get structure from string!")
            structure = Structure.from_str(source, fmt, sort=True)
        else:
            raise ValueError(source, "not supported!")

        if name is not None:
            if not isinstance(name, six.string_types):
                raise ValueError("structure name needs to be a string")
            elif "." in name:
                raise ValueError("structure name cannot contain dots (.)")

        mpr = MPRester()
        if not mpr.api_key:
            raise ValueError(
                "API key not set. Run `pmg config --add PMG_MAPI_KEY <USER_API_KEY>`."
            )
        matched_mpids = mpr.find_structure(structure)
        formula = get_composition_from_string(structure.composition.formula)
        if not matched_mpids:
            if identifier is None:
                identifier = formula
                print(
                    "Structure not found in MP! Please submit via MPComplete to "
                    "obtain mp-id or manually choose an anchor mp-id! Continuing "
                    "with {} as identifier!".format(identifier))
            else:
                print("Structure not found in MP! Forcing {} as identifier!".
                      format(identifier))
        elif identifier is None:
            identifier = matched_mpids[0]
            if len(matched_mpids) > 1:
                print("Multiple matching structures found in MP. Using",
                      identifier)
        elif identifier not in matched_mpids:
            msg = "Structure does not match {} but instead {}!".format(
                identifier, matched_mpids)
            raise ValueError(msg)

        idx = len(
            self.document.get(identifier, {}).get(mp_level01_titles[3], {}))
        sub_key = formula if name is None else name
        if sub_key in self.document.get(identifier,
                                        {}).get(mp_level01_titles[3], {}):
            sub_key += "_{}".format(idx)
        self.document.rec_update(
            nest_dict(structure.as_dict(),
                      [identifier, mp_level01_titles[3], sub_key]))
        return identifier
Example #6
0
with open('mp.2019.04.01.json', 'r') as f:
    structure_data = {i['material_id']: i['structure'] for i in json.load(f)}
print('All structures in mp.2019.04.01.json contain %d structures' %
      len(structure_data))

##  Band gap data
with gzip.open('data_no_structs.json.gz', 'rb') as f:
    bandgap_data = json.loads(f.read())

useful_ids = set.union(*[set(bandgap_data[i].keys()) for i in ALL_FIDELITIES
                         ])  # mp ids that are used in training
print('Only %d structures are used' % len(useful_ids))
print('Calculating the graphs for all structures... this may take minutes.')
structure_data = {i: structure_data[i] for i in useful_ids}
structure_data = {
    i: crystal_graph.convert(Structure.from_str(j, fmt='cif'))
    for i, j in structure_data.items()
}

##  Generate graphs with fidelity information
graphs = []
targets = []
material_ids = []

for fidelity_id, fidelity in enumerate(ALL_FIDELITIES):
    for mp_id in bandgap_data[fidelity]:
        graph = deepcopy(structure_data[mp_id])

        # The fidelity information is included here by changing the state attributes
        # PBE: 0, GLLB-SC: 1, HSE: 2, SCAN: 3
        graph['state'] = [fidelity_id]
Example #7
0
tqdm.pandas()  # prime progress_apply functionality

final_dir = os.path.dirname(os.path.abspath(__file__))

idx_list = []
structs = []
E_vasp_list = []
meta_list = []
ht_paths = []

for f in glob.glob(final_dir + "/raw/*.poscar", recursive=True):
    task_id = f.split("/")[-1].split(".")[0]

    with open(f) as s:
        s = s.read()
        struct = Structure.from_str(s, fmt="poscar")

        lines = s.split("\n")

        num = lines[6].split()
        E_vasp_per_atom = float(lines[0].split()[0]) / sum(int(a) for a in num)

        ht_path = lines[0].split()[1]
        meta_data = "[" + lines[0].split("[")[-1]

    idx_list.append(task_id)
    structs.append(struct)
    E_vasp_list.append(E_vasp_per_atom)
    ht_paths.append(ht_path)
    meta_list.append(meta_data)
Example #8
0
    # load data
    cif_path = path.normpath(path.join(getcwd(), args.cif_data))
    cif_data = h5py.File(cif_path, "r")
    battery_table = pd.read_csv(args.battery_data, index_col=False)
    element_data = ElementDataSingleton.get_instance(
        element_data_path=args.element_data)

    # create features
    features = np.zeros((len(battery_table), NUM_OF_FEATURE))
    for i, (id_charge, id_discharge, ion) in tqdm(
            enumerate(
                zip(battery_table['id_charge'], battery_table['id_discharge'],
                    battery_table['working_ion']))):

        # load crystal object from cif
        charge_crystal = Structure.from_str(cif_data[id_charge].value, 'cif')
        discharge_crystal = Structure.from_str(cif_data[id_discharge].value,
                                               'cif')

        # specific features
        finder = SpacegroupAnalyzer(charge_crystal)
        space_group_feat = np.array([finder.get_space_group_number()])
        crystal_system_feat = create_feature_from_crystal_system(
            finder.get_crystal_system())
        ion_feat = create_feature_from_wokring_ion(ion)
        dischr_comp = Composition(discharge_crystal.formula)
        ion_concentrate = np.array(
            [dischr_comp.get_atomic_fraction(Element(ion))])

        # calculate features from element property
        charge_formula = charge_crystal.formula