def __init__(self, file_path=None, elements_list=None, basenames_list=None, calculation_type='lda_paw', minimal_form=None): super(Potcar, self).__init__(file_path) if file_path: if self.get_lines_containing_string("PAW_PBE"): #be careful if potcars different than used to in future self.calculation_type = 'gga_paw_pbe' else: self.calculation_type = 'lda_paw' if minimal_form: calculation_type = minimal_form['calculation_type'] basenames_list = minimal_form['basenames'] if elements_list or basenames_list: self.calculation_type = calculation_type element_mapping_file = File(Potcar.element_mapping_path) element_mapping_string = str(element_mapping_file) potcar_dict = json.loads(element_mapping_string) base_path = potcar_dict[calculation_type]['path'] if elements_list: potcar_paths = [Path.clean(base_path, potcar_dict[calculation_type][element], 'POTCAR') for element in elements_list] elif basenames_list: potcar_paths = [Path.clean(base_path, basename, 'POTCAR') for basename in basenames_list] concatenated_file = File() for path in potcar_paths: concatenated_file = concatenated_file + File(path) self.lines = concatenated_file.lines
def test_write_to_path(self): file_path = Path.clean(self.data_path, 'small_file.txt') file = File(file_path) file[0] += " for line 0" file[3] = "line 3" file += "" file += "here\nand here" file += "" self.assertEqual(file.lines, [ 'Small file for line 0', ' Very small ', '', 'line 3', '', 'here', 'and here', '' ]) file.write_to_path( Path.clean(self.data_path, 'small_file_ammended.txt')) file_2 = File(Path.clean(self.data_path, 'small_file_ammended.txt')) file_2[2] = "no more" file_2.write_to_path() file_3 = File(Path.clean(self.data_path, 'small_file_ammended.txt')) self.assertEqual(file_3.lines, [ 'Small file for line 0', ' Very small ', 'no more', 'line 3', '', 'here', 'and here', '' ])
def test_add(self): file_path = Path.clean(self.data_path, 'small_file.txt') file = File(file_path) add_str = "string to add" right_full_str = file + add_str self.assertEqual(right_full_str, "Small file\n Very small \n\nstring to add") l_add_str = " left string to add" left_full_str = l_add_str + file self.assertEqual(left_full_str, " left string to addSmall file\n Very small \n\n") file_path_1 = Path.clean(self.data_path, 'small_file.txt') file_path_2 = Path.clean(self.data_path, 'small_file_2.txt') first_file = File(file_path_1) second_file = File(file_path_2) final_file = first_file + second_file self.assertEqual(final_file.lines, [ 'Small file', ' Very small ', '', '', 'Small file 2', ' Not as small ', '' ])
def test_init(self): with self.assertRaises(IOError): file = File(Path.clean(self.data_path, 'file.txt')) file = File() self.assertEqual(file.lines, []) self.assertEqual(file.load_path, None) with self.assertRaises(IOError): file.write_to_path() file_path = Path.clean(self.data_path, 'file1.txt') file = File(file_path) self.assertEqual(file.lines[0], "This is a test file") self.assertEqual(file.lines[4], "line 5") self.assertEqual(file.lines[6], "end of testing file") with self.assertRaises(IndexError): file.lines[7] self.assertEqual(file.load_path, file_path) file_path = Path.clean(self.data_path, 'small_file.txt') file = File(file_path) self.assertEqual(file.lines, ['Small file', ' Very small ', '']) file_path = Path.clean(self.data_path, 'empty.txt') file = File(file_path) self.assertEqual(file.lines, []) file_path = Path.clean(self.data_path, 'almost_empty.txt') file = File(file_path) #this file contains: line 1: '\n' line 2: '' self.assertEqual(file.lines, [''])
def test_init(self): file_path = Path.clean(self.data_path, "kpt_1") kpoints = Kpoints(file_path) self.assertEqual(kpoints.scheme, 'Gamma') kpoints.scheme = "monkhorst" self.assertEqual(kpoints.scheme, 'Monkhorst') self.assertEqual(kpoints.subdivisions_list, [4, 2, 4]) kpoints.subdivisions_list = [6, 6, 8] self.assertEqual(kpoints.subdivisions_list, [6, 6, 8]) new_path = Path.clean(self.data_path, "new_kpt_1") kpoints.write_to_path(new_path) kpoints_2 = Kpoints(new_path) self.assertEqual(kpoints_2.subdivisions_list, [6, 6, 8]) self.assertEqual(kpoints.scheme, 'Monkhorst') with self.assertRaises(Exception): kpoints_2.scheme = "Lonkhorst" with self.assertRaises(Exception): kpoints_2.subdivisions_list = ['2', '4', '5', '6'] kpoints_3 = Kpoints(scheme_string="Gamma", subdivisions_list=[4, 6, 8]) self.assertEqual(str(kpoints_3), 'Kpoints File\n0\nGamma\n4 6 8\n0 0 0\n')
def test_str(self): file = File(Path.clean(self.data_path, 'small_file.txt')) self.assertEqual(str(file), "Small file\n Very small \n\n") file = File(Path.clean(self.data_path, 'empty.txt')) self.assertEqual(str(file), "") file = File(Path.clean( self.data_path, 'almost_empty.txt')) #this file contains: line 1: '\n' line 2: '' self.assertEqual(str(file), "\n")
def test_init(self): file_path = Path.clean(self.data_path, "poscar_small") poscar = Poscar(file_path) self.assertEqual(poscar.species_list, ['Si', 'O']) self.assertEqual(poscar.lines, [ 'Poscar', '1.0', '5.0 0.2 0.1', '0.4\t 6.0 0.7', '-0.2 0.0 7.7 ', 'Si O', '2 1', 'Direct', '0.11 0.22 0.33', '0.33 0.22 0.11', '0.22 0.33 0.11 ' ]) self.assertEqual(poscar.species_count_list, [2, 1]) self.assertEqual(poscar.coordinate_mode, 'Direct') self.assertEqual( poscar.coordinates, [[0.11, 0.22, 0.33], [0.33, 0.22, 0.11], [0.22, 0.33, 0.11]]) lattice = [[2.2, 2.3, 2.1], [1.2, 3.3, 0.0], [-1.2, -2.2, 4.4]] species_list = ['K', 'V', 'O'] species_count_list = [1, 2, 3] coordinate_mode = 'cart' coordinates = [[0.2, 0.3, 0.4], [0.5, 0.5, 0.1], [-0.01, 0.1, 0.01], [2.33, 6.5, 3.2], [0.0, 0.1, -0.1], [0.1, 0.5, 0.5]] poscar = Poscar(None, lattice, species_list, species_count_list, coordinate_mode, coordinates) self.assertEqual(poscar.species_list, ['K', 'V', 'O']) self.assertEqual(poscar.lines, [ 'Poscar', '1.0', '2.2 2.3 2.1', '1.2 3.3 0.0', '-1.2 -2.2 4.4', 'K V O', '1 2 3', 'Cartesian', '0.2 0.3 0.4', '0.5 0.5 0.1', '-0.01 0.1 0.01', '2.33 6.5 3.2', '0.0 0.1 -0.1', '0.1 0.5 0.5' ]) self.assertEqual(poscar.species_count_list, [1, 2, 3]) self.assertEqual(poscar.coordinate_mode, 'Cartesian') self.assertEqual(poscar.coordinates, coordinates)
def npar_converger(base_path, structure, npar_list, base_kpoints_scheme, base_kpoints_subdivisions_list, base_ediff, base_encut, node_count): """Takes in a structure, set of npars, and base params and runs set in base_path""" encut_convergence_set_path = Path.clean(base_path) Path.make(encut_convergence_set_path) for npar in npar_list: run_path = Path.join(encut_convergence_set_path, str(npar)) input_dictionary = { 'external_relaxation_count': 0, 'kpoint_schemes_list': [base_kpoints_scheme], 'kpoint_subdivisions_lists': [base_kpoints_subdivisions_list], 'submission_script_modification_keys_list': ['100'], 'submission_node_count_list': [node_count], 'ediff': [base_ediff], 'encut': [base_encut], 'npar': [npar] } vasp_relaxation = VaspRelaxation(run_path, structure, input_dictionary, verbose=False) if vasp_relaxation.update(): print "npar:", npar, "node_count:", node_count, round( vasp_relaxation.get_final_energy(True), 5), round(vasp_relaxation.total_time, 2) else: pass
def write_input_files_to_path(self): """ Simply write files to path """ if self.initial_structure: self.initial_structure.to_poscar_file_path(Path.clean(self.path, 'POSCAR')) elif not Path.exists(self.contcar_path): raise Exception("Neither an initial structure nor an existing contcar path have been provided. Nowhere to get the structure.") else: Path.copy(self.contcar_path, self.get_extended_path('POSCAR')) for file_path in [self.chargecar_path, self.wavecar_path]: if Path.exists(file_path): Path.copy(file_path, self.path) self.initial_incar.write_to_path(Path.join(self.path, 'INCAR')) if self.initial_kpoints: self.initial_kpoints.write_to_path(Path.join(self.path, 'KPOINTS')) elif 'kspacing' not in self.incar: raise Exception("If no kpoints is provided, must have kspacing parameter in incar set") self.initial_potcar.write_to_path(Path.join(self.path, 'POTCAR')) self.submission_script_file.write_to_path(Path.join(self.path, 'submit.sh'))
def test_loaded(self): file_path = Path.clean(self.data_path, "incar_1") incar = Incar(file_path) self.assertEqual(incar.lines, ['', 'Comment here #messy messy', 'ALGO = Fast #stuff here', 'whats up', '', '', 'EDIFF = 0.00075', 'ENCUT = 520', 'IBRION = 2', 'ICHARG = 1', 'ISIF = 3', 'ISMEAR = -5', 'ISPIN = 2', 'LORBIT = 11 #comment with equals sign', '', '', '', 'LREAL = Auto', 'LWAVE = False', 'MAGMOM = 15*0.6', 'NELM = 100', 'NSW = 99', 'PREC = Accurate', '', '#lonely sigma with equals signequalsequals!', '', 'X = y #equalsequals', 'f #equals', 'SIGMA = 0.05']) self.assertEqual(incar.dict.items(), [('ALGO', 'Fast'), ('EDIFF', '0.00075'), ('ENCUT', '520'), ('IBRION', '2'), ('ICHARG', '1'), ('ISIF', '3'), ('ISMEAR', '-5'), ('ISPIN', '2'), ('LORBIT', '11'), ('LREAL', 'Auto'), ('LWAVE', 'False'), ('MAGMOM', '15*0.6'), ('NELM', '100'), ('NSW', '99'), ('PREC', 'Accurate'), ('X', 'y'), ('SIGMA', '0.05')])
def test_init(self): site = Site() site['position'] = [0.1, 0.2, 0.4, "dir"] site['type'] = 'Ba' site_2 = Site() site_2['position'] = [0.6, 0.22, 0.44, "cart"] site_2['type'] = 'Ti' structure = Structure(lattice=Lattice(a=[3.4, 0.1, 0.2], b=[2.3, 5.0, 0.0], c=[0.0, 0.0, 1.0]), sites=SiteCollection([site, site_2])) self.assertEqual(structure.lattice.to_array(), [[3.4, 0.1, 0.2], [2.3, 5.0, 0.0], [0.0, 0.0, 1.0]]) self.assertEqual(structure.sites.get_sorted_list()[0]['type'], 'Ba') self.assertEqual(structure.sites.get_coordinates_list(), [[0.1, 0.2, 0.4], [0.6, 0.22, 0.44]]) file_path = Path.clean(self.data_path, "poscar_small") structure = Structure(file_path) self.assertEqual(structure.lattice.to_array(), [[5.0, 0.2, 0.1], [0.4, 6.0, 0.7], [-0.2, 0.0, 7.7]]) self.assertEqual( structure.sites.get_sorted_list()[1]['coordinate_mode'], 'Direct') self.assertEqual( structure.get_coordinates_list(), [[0.11, 0.22, 0.33], [0.33, 0.22, 0.11], [0.22, 0.33, 0.11]]) write_file_path = Path.clean(self.data_path, "poscar_small_rewritten") structure.to_poscar_file_path(write_file_path) structure = Structure(write_file_path) self.assertEqual(structure.lattice.to_array(), [[5.0, 0.2, 0.1], [0.4, 6.0, 0.7], [-0.2, 0.0, 7.7]]) self.assertEqual( structure.sites.get_sorted_list()[1]['coordinate_mode'], 'Direct') self.assertEqual( structure.get_coordinates_list(), [[0.11, 0.22, 0.33], [0.33, 0.22, 0.11], [0.22, 0.33, 0.11]])
def get_structure_list(path): """loads in poscars at path and returns list of structures""" path = Path.clean(path) files = Path.get_list_of_files_at_path(path) structs = {} for file in files: structs[file] = Structure(Path.join(path, file)) return structs
def write_input_files_to_path(self, structure, incar, kpoints, potcar, submission_script_file, wavecar_path, chargecar_path): """ Simply write files to path """ structure.to_poscar_file_path(Path.clean(self.path, 'POSCAR')) incar.write_to_path(Path.clean(self.path, 'INCAR')) if kpoints: kpoints.write_to_path(Path.clean(self.path, 'KPOINTS')) elif 'kspacing' not in incar: raise Exception("If no kpoints is provided, must have kspacing parameter in incar set") potcar.write_to_path(Path.clean(self.path, 'POTCAR')) submission_script_file.write_to_path(Path.clean(self.path, 'submit.sh')) if wavecar_path and Path.exists(wavecar_path): Path.copy(wavecar_path, self.get_extended_path('WAVECAR')) if chargecar_path and Path.exists(chargecar_path): Path.copy(chargecar_path, self.get_extended_path('CHARGECAR'))
def get_submission_file(): if QueueAdapter.host in ['Fenrir', 'Asathor']: return File(Path.clean("/home/angsten/.submit.sh")) elif QueueAdapter.host == 'Tom_hp': file = File() file[0] = 'fake submit script' file[1] = 'nodes = 3' return file elif QueueAdapter.host == 'Savio': return File('/global/home/users/angsten/submit.sh')
def test_conversion(self): file_path = Path.clean(self.data_path, "big_posc") structure = Structure(file_path) structure_2 = Structure(file_path) structure_2.convert_sites_to_cartesian_coordinates() structure_2.convert_sites_to_direct_coordinates() print structure for i in range(len(structure.sites)): for j in range(3): self.assertTrue( structure.sites[i]['position'][j] - structure_2.sites[i]['position'][j] < 0.00000000001)
def __init__(self, path, initial_structure=None, incar=None, kpoints=None, potcar=None, submission_script_file=None, contcar_path=None, wavecar_path=None, chargecar_path=None): """ """ if initial_structure and contcar_path: raise Exception("Both an initial initial_structure and a contcar path is given. Only one is allowed.") self.path = Path.clean(path) self.initial_structure = initial_structure self.initial_incar = incar self.initial_kpoints = kpoints self.initial_potcar = potcar self.submission_script_file = submission_script_file self.contcar_path = contcar_path self.wavecar_path = wavecar_path self.chargecar_path = chargecar_path
def __init__(self, path, structure=None, incar=None, kpoints=None, potcar=None, submission_script_file=None, input_set=None, wavecar_path=None, chargecar_path=None): """ Cases for __init__: 1. path does not exist or is empty => make the directory, enforce input file arguments all exists, write out input files to directory 2. path exists and is not empty 1. path/.job_id does not exist 1. path has all 5 input files written to it already => do nothing if not all five input parameters exist, else overwrite current input files to directory 2. path does not have all 5 input files (has some subset or none) => enforce input file arguments all exists, write out input files to directory 2. path/.job_id exists => do nothing """ self.path = Path.clean(path) if input_set: structure = input_set.structure incar = input_set.incar kpoints = input_set.kpoints potcar = input_set.potcar submission_script_file = input_set.submission_script_file all_essential_input_parameters_exist = not bool(filter(lambda x: x == None, [structure, incar, potcar, submission_script_file])) if not Path.exists(self.path) or Path.is_empty(self.path): if not all_essential_input_parameters_exist: raise Exception("All five vasp input files must be input for run to be initialized.") else: Path.make(self.path) self.write_input_files_to_path(structure, incar, kpoints, potcar, submission_script_file, wavecar_path, chargecar_path) else: if self.job_id_string: pass else: if self.all_input_files_are_present(): #all input files are written to directory if all_essential_input_parameters_exist: #overwrite what's there self.write_input_files_to_path(structure, incar, kpoints, potcar, submission_script_file, wavecar_path, chargecar_path) else: pass #do nothing - don't have the necessary inputs to start a run else: #not all input files currently exist - must have necessary input params to overwrite if not all_essential_input_parameters_exist: raise Exception("All five vasp input files must be input for run with incomplete inputs at path to be initialized.") else: self.write_input_files_to_path(structure, incar, kpoints, potcar, submission_script_file, wavecar_path)
def encut_converger(base_path, structure, encut_list, base_kpoints_scheme, base_kpoints_subdivisions_list, base_ediff): """Takes in a structure, set of encuts, and base params and runs set in base_path""" encut_convergence_set_path = Path.clean(base_path) Path.make(encut_convergence_set_path) for encut in encut_list: run_path = Path.join(encut_convergence_set_path, str(encut)) kpoints = Kpoints(scheme_string=base_kpoints_scheme, subdivisions_list=base_kpoints_subdivisions_list) incar = IncarMaker.get_static_incar({'ediff':base_ediff, 'encut':encut}) input_set = VaspInputSet(structure, kpoints, incar) vasp_run = VaspRun(run_path, input_set=input_set, verbose=False) if vasp_run.update(): print encut, round(vasp_run.outcar.energy_per_atom, 5), round(vasp_run.outcar.get_calculation_time_in_core_hours(), 2) else: pass
class Test(TestCase): class_title = 'Kpoints' data_dir_path = Path.clean(os.path.dirname(__file__), 'data_' + class_title) def setUp(self): self.data_path = Path.clean(self.__class__.data_dir_path) def test_init(self): file_path = Path.clean(self.data_path, "kpt_1") kpoints = Kpoints(file_path) self.assertEqual(kpoints.scheme, 'Gamma') kpoints.scheme = "monkhorst" self.assertEqual(kpoints.scheme, 'Monkhorst') self.assertEqual(kpoints.subdivisions_list, [4, 2, 4]) kpoints.subdivisions_list = [6, 6, 8] self.assertEqual(kpoints.subdivisions_list, [6, 6, 8]) new_path = Path.clean(self.data_path, "new_kpt_1") kpoints.write_to_path(new_path) kpoints_2 = Kpoints(new_path) self.assertEqual(kpoints_2.subdivisions_list, [6, 6, 8]) self.assertEqual(kpoints.scheme, 'Monkhorst') with self.assertRaises(Exception): kpoints_2.scheme = "Lonkhorst" with self.assertRaises(Exception): kpoints_2.subdivisions_list = ['2', '4', '5', '6'] kpoints_3 = Kpoints(scheme_string="Gamma", subdivisions_list=[4, 6, 8]) self.assertEqual(str(kpoints_3), 'Kpoints File\n0\nGamma\n4 6 8\n0 0 0\n')
class Test(TestCase): class_title = 'Potcar' data_dir_path = Path.clean(os.path.dirname(__file__), 'data_' + class_title) def setUp(self): self.data_path = Path.clean(self.__class__.data_dir_path) def test_init(self): potcar = Potcar(elements_list=['Ba']) self.assertEqual(potcar.get_titles(), ['PAW Ba_sv 17Apr2000']) self.assertEqual(potcar.get_elements_list(), ['Ba']) potcar_2 = Potcar(elements_list=['O', 'Ti', 'Ba']) self.assertEqual( potcar_2.get_titles(), ['PAW O 22Mar2012', 'PAW Ti_sv 26Sep2005', 'PAW Ba_sv 17Apr2000']) self.assertEqual(potcar_2.get_elements_list(), ['O', 'Ti', 'Ba'])
def kpoints_converger(base_path, structure, kpoints_lists, base_kpoints_scheme, base_encut, base_ediff, incar_modification_dictionary=None): convergence_set_path = Path.clean(base_path) Path.make(convergence_set_path) for kpoints_list in kpoints_lists: run_path = Path.join(convergence_set_path, "_".join(str(kpoints) for kpoints in kpoints_list)) kpoints = Kpoints(scheme_string=base_kpoints_scheme, subdivisions_list=kpoints_list) incar_mod = {'ediff':base_ediff, 'encut':base_encut} if incar_modification_dictionary: for key, value in incar_modification_dictionary.items(): incar_mod[key] = value incar = IncarMaker.get_static_incar(incar_mod) input_set = VaspInputSet(structure, kpoints, incar) vasp_run = VaspRun(run_path, input_set=input_set, verbose=False) if vasp_run.update(): print "_".join(str(kpoints) for kpoints in kpoints_list), round(vasp_run.outcar.energy_per_atom, 5), round(vasp_run.outcar.get_calculation_time_in_core_hours(), 2) else: vasp_run.view(['kpoints','_job_output.txt'])
def outcar(self): outcar_path = Path.clean(self.path, 'OUTCAR') if Path.exists(outcar_path): return Outcar(outcar_path) else: return None
def potcar(self): potcar_path = Path.clean(self.path, 'POTCAR') if Path.exists(potcar_path): return Potcar(potcar_path) else: return None
def kpoints(self): kpoints_path = Path.clean(self.path, 'KPOINTS') if Path.exists(kpoints_path): return Kpoints(kpoints_path) else: return None
def incar(self): incar_path = Path.clean(self.path, 'INCAR') if Path.exists(incar_path): return Incar(incar_path) else: return None
class Test(TestCase): class_title = 'File' data_dir_path = Path.clean(os.path.dirname(__file__), 'data_' + class_title) def setUp(self): self.data_path = Path.clean(self.__class__.data_dir_path) def test_init(self): with self.assertRaises(IOError): file = File(Path.clean(self.data_path, 'file.txt')) file = File() self.assertEqual(file.lines, []) self.assertEqual(file.load_path, None) with self.assertRaises(IOError): file.write_to_path() file_path = Path.clean(self.data_path, 'file1.txt') file = File(file_path) self.assertEqual(file.lines[0], "This is a test file") self.assertEqual(file.lines[4], "line 5") self.assertEqual(file.lines[6], "end of testing file") with self.assertRaises(IndexError): file.lines[7] self.assertEqual(file.load_path, file_path) file_path = Path.clean(self.data_path, 'small_file.txt') file = File(file_path) self.assertEqual(file.lines, ['Small file', ' Very small ', '']) file_path = Path.clean(self.data_path, 'empty.txt') file = File(file_path) self.assertEqual(file.lines, []) file_path = Path.clean(self.data_path, 'almost_empty.txt') file = File(file_path) #this file contains: line 1: '\n' line 2: '' self.assertEqual(file.lines, ['']) def test_str(self): file = File(Path.clean(self.data_path, 'small_file.txt')) self.assertEqual(str(file), "Small file\n Very small \n\n") file = File(Path.clean(self.data_path, 'empty.txt')) self.assertEqual(str(file), "") file = File(Path.clean( self.data_path, 'almost_empty.txt')) #this file contains: line 1: '\n' line 2: '' self.assertEqual(str(file), "\n") def test_add(self): file_path = Path.clean(self.data_path, 'small_file.txt') file = File(file_path) add_str = "string to add" right_full_str = file + add_str self.assertEqual(right_full_str, "Small file\n Very small \n\nstring to add") l_add_str = " left string to add" left_full_str = l_add_str + file self.assertEqual(left_full_str, " left string to addSmall file\n Very small \n\n") file_path_1 = Path.clean(self.data_path, 'small_file.txt') file_path_2 = Path.clean(self.data_path, 'small_file_2.txt') first_file = File(file_path_1) second_file = File(file_path_2) final_file = first_file + second_file self.assertEqual(final_file.lines, [ 'Small file', ' Very small ', '', '', 'Small file 2', ' Not as small ', '' ]) def test_overrides(self): file = File() self.assertFalse(file) file[2] = ' inserted line ' self.assertEqual(file.lines, ['', '', ' inserted line ']) file[1] = 'add this line\n and this one where index 1 was' self.assertEqual(file.lines, [ '', 'add this line', ' and this one where index 1 was', ' inserted line ' ]) file[1] = 'replaced add this line' self.assertEqual(file.lines, [ '', 'replaced add this line', ' and this one where index 1 was', ' inserted line ' ]) self.assertEqual( file.lines[1:3], ['replaced add this line', ' and this one where index 1 was']) del file[1] del file[0:2] self.assertEqual(file.lines, [' inserted line ']) self.assertFalse("home is where the heart is" in file) self.assertTrue("line" in file) file += "new line added" self.assertEqual(file.lines, [' inserted line ', 'new line added']) file.insert(0, 'inserted at beginning') file.insert(2, 'right before new line added line') self.assertEqual(file.lines, [ 'inserted at beginning', ' inserted line ', 'right before new line added line', 'new line added' ]) self.assertTrue(file) self.assertEqual(len(file), 4) l = [ 'inserted at beginning', ' inserted line ', 'right before new line added line', 'new line added' ] for x, item in enumerate(file): self.assertEqual(item, l[x]) def test_write_to_path(self): file_path = Path.clean(self.data_path, 'small_file.txt') file = File(file_path) file[0] += " for line 0" file[3] = "line 3" file += "" file += "here\nand here" file += "" self.assertEqual(file.lines, [ 'Small file for line 0', ' Very small ', '', 'line 3', '', 'here', 'and here', '' ]) file.write_to_path( Path.clean(self.data_path, 'small_file_ammended.txt')) file_2 = File(Path.clean(self.data_path, 'small_file_ammended.txt')) file_2[2] = "no more" file_2.write_to_path() file_3 = File(Path.clean(self.data_path, 'small_file_ammended.txt')) self.assertEqual(file_3.lines, [ 'Small file for line 0', ' Very small ', 'no more', 'line 3', '', 'here', 'and here', '' ])
def __init__(self, vasp_calculation_input_dictionary): vasp_calculation_input_dictionary = copy.deepcopy( vasp_calculation_input_dictionary) vasp_calculation_input_dictionary = { k.lower(): v for k, v in vasp_calculation_input_dictionary.items() } #enforce all keys lowercase path = Path.clean(vasp_calculation_input_dictionary.pop('path')) information_structure = None #used for number of nodes and potcar if isinstance(vasp_calculation_input_dictionary['structure'], Structure): initial_structure = vasp_calculation_input_dictionary.pop( 'structure') information_structure = initial_structure contcar_path = None else: initial_structure = None contcar_path = vasp_calculation_input_dictionary.pop('structure') information_structure = Structure(contcar_path) wavecar_path = vasp_calculation_input_dictionary.pop( 'wavecar_path' ) if 'wavecar_path' in vasp_calculation_input_dictionary else None chargecar_path = vasp_calculation_input_dictionary.pop( 'chargecar_path' ) if 'chargecar_path' in vasp_calculation_input_dictionary else None incar_template = vasp_calculation_input_dictionary.pop( 'incar_template' ) if 'incar_template' in vasp_calculation_input_dictionary else None kpoints_scheme = vasp_calculation_input_dictionary.pop( 'kpoints_scheme' ) if 'kpoints_scheme' in vasp_calculation_input_dictionary else None kpoints_list = [ int(x) for x in vasp_calculation_input_dictionary.pop( 'kpoints_list').split(' ') ] if ('kpoints_list' in vasp_calculation_input_dictionary and vasp_calculation_input_dictionary['kpoints_list'] != None ) else None potcar_type = vasp_calculation_input_dictionary.pop( 'potcar_type' ) if 'potcar_type' in vasp_calculation_input_dictionary else 'lda_paw' vasp_code_type = vasp_calculation_input_dictionary.pop( 'vasp_code_type' ) if 'vasp_code_type' in vasp_calculation_input_dictionary else 'standard' node_count = vasp_calculation_input_dictionary.pop( 'node_count' ) if 'node_count' in vasp_calculation_input_dictionary else None use_mp_hubbard_u = vasp_calculation_input_dictionary.pop( 'use_mp_hubbard_u' ) if 'use_mp_hubbard_u' in vasp_calculation_input_dictionary else None for file_path in [wavecar_path, chargecar_path]: if file_path != None and not Path.exists(file_path): print "Warning: Path " + str( file_path) + " specified does not exist. Not using." #raise Exception("Path " + str(file_path) + " specified does not exist.") if kpoints_scheme != None and kpoints_list != None: kpoints = Kpoints(scheme_string=kpoints_scheme, subdivisions_list=kpoints_list) if 'kspacing' in vasp_calculation_input_dictionary: raise Exception( "kpoints are being specified by more than one method.") elif 'kspacing' not in vasp_calculation_input_dictionary: raise Exception( "If kpoints aren't explicitly defined through a scheme and a list, the kspacing tag must be present in the incar." ) else: kpoints = None potcar = Potcar(elements_list=information_structure.get_species_list(), calculation_type=potcar_type) submission_script_file = QueueAdapter.get_submission_file() if os.environ['QUEUE_ADAPTER_HOST'] != 'Savio': if node_count == None: submission_script_file = QueueAdapter.modify_number_of_cores_from_num_atoms( submission_script_file, information_structure.site_count) else: submission_script_file = QueueAdapter.set_number_of_nodes( submission_script_file, node_count) submission_script_file = QueueAdapter.modify_submission_script( submission_script_file, modification_key=vasp_code_type) incar_modifiers = vasp_calculation_input_dictionary #whatever is left should only be incar modifiers - we popped all other keys for key, value in incar_modifiers.items( ): #make sure there are no None values - these should not be put in INCAR if value in [None, 'None']: del incar_modifiers[key] if 'encut' in incar_modifiers and ( 0.1 < incar_modifiers['encut']) and ( incar_modifiers['encut'] < 10.0): #Should use this as a multiplier times enmax enmax = potcar.get_enmax() incar_modifiers['encut'] = int(incar_modifiers['encut'] * enmax) if incar_template == 'static': incar = IncarMaker.get_static_incar( custom_parameters_dictionary=incar_modifiers) elif incar_template == 'external_relaxation': incar = IncarMaker.get_external_relaxation_incar( custom_parameters_dictionary=incar_modifiers) elif incar_template != None: raise Exception("Incar template " + str(incar_template) + " not valid") else: incar = Incar() incar.modify_from_dictionary(incar_modifiers) if 'lreal' not in incar: if information_structure.site_count > 20: incar['lreal'] = 'Auto' else: incar['lreal'] = False if 'npar' not in incar: if os.environ['QUEUE_ADAPTER_HOST'] == 'Savio': incar['npar'] = 4 else: incar['npar'] = QueueAdapter.get_optimal_npar( submission_script_file) elif incar['npar'] in ['Remove', 'remove']: del incar['npar'] ###################TEMPORARILY HARDCODED FOR PEROVSKITES########################################## if use_mp_hubbard_u: u_species = initial_structure.get_species_list()[1] mp_hubbard_u_values = { 'Co': 3.32, 'Cr': 3.7, 'Fe': 5.3, 'Mn': 3.9, 'Mo': 4.38, 'Ni': 6.2, 'V': 3.25, 'W': 6.2 } if u_species in mp_hubbard_u_values.keys(): u_value = mp_hubbard_u_values[u_species] incar['LDAU'] = True incar['LDAUJ'] = '0 0 0' incar['LDAUL'] = '0 2 0' incar['LDAUPRINT'] = 1 incar['LDAUTYPE'] = 2 incar['LDAUU'] = '0 ' + str(u_value) + ' 0' incar['LMAXMIX'] = 4 incar['LORBIT'] = 11 super(VaspCalculationGenerator, self).__init__(path=path, initial_structure=initial_structure, incar=incar, kpoints=kpoints, potcar=potcar, submission_script_file=submission_script_file, contcar_path=contcar_path, wavecar_path=wavecar_path, chargecar_path=chargecar_path)
def setUp(self): self.data_path = Path.clean(self.__class__.data_dir_path)
class Potcar(File): """ Can initialize from an existing potcar file (Potcar('./POTCAR')) Can initialize from a string of elements and whether or not to use LDA or GGA (Potcar(['Ba','Ti','O'], lda=False)) In this case, set of predefined potcars will be used Assumes lda = True if calculation type is not specified Can initialize from a list of basenames which might look like ['Ba_sv', 'Ti_sv', 'O'] Can initialize from a minimal_form which looks like {'basenames':['Ba_sv', 'Ti_sv', 'O'], 'calculation_type':'lda'} """ element_mapping_path = Path.clean(os.path.dirname(__file__),'potcar_element_mapping.json') def __init__(self, file_path=None, elements_list=None, basenames_list=None, calculation_type='lda_paw', minimal_form=None): super(Potcar, self).__init__(file_path) if file_path: if self.get_lines_containing_string("PAW_PBE"): #be careful if potcars different than used to in future self.calculation_type = 'gga_paw_pbe' else: self.calculation_type = 'lda_paw' if minimal_form: calculation_type = minimal_form['calculation_type'] basenames_list = minimal_form['basenames'] if elements_list or basenames_list: self.calculation_type = calculation_type element_mapping_file = File(Potcar.element_mapping_path) element_mapping_string = str(element_mapping_file) potcar_dict = json.loads(element_mapping_string) base_path = potcar_dict[calculation_type]['path'] if elements_list: potcar_paths = [Path.clean(base_path, potcar_dict[calculation_type][element], 'POTCAR') for element in elements_list] elif basenames_list: potcar_paths = [Path.clean(base_path, basename, 'POTCAR') for basename in basenames_list] concatenated_file = File() for path in potcar_paths: concatenated_file = concatenated_file + File(path) self.lines = concatenated_file.lines def get_titles(self): """Returns list like ['PAW Ba_sv 17Apr2000', 'PAW Ti_sv 26Sep2005', 'PAW O 22Mar2012']""" titles_list = self.get_lines_containing_string('TITEL') return [x.split("= ")[1].rstrip() for x in titles_list] def get_elements_list(self): """Returns list like ['Ba', 'Ti', 'O']""" return [x.split(" ")[1].split("_")[0] for x in self.get_titles()] def get_basenames_list(self): """Returns list like ['Ba_sv', 'Ti_sv', 'O']""" return [x.split(" ")[1] for x in self.get_titles()] def get_minimal_form(self): """Returns minimal form (a dict like {'basenames':['Ba_sv', 'Ti_sv', 'O'], 'calculation_type':'lda'])""" return {'basenames':self.get_basenames_list(), 'calculation_type':self.calculation_type} def get_enmax(self): """Returns maximum enmax out of all species' enmax values""" enmax_lines_list = self.get_lines_containing_string('ENMAX') enmax_values_list = [] for enmax_line in enmax_lines_list: enmax_line = su.remove_extra_spaces(enmax_line) enmax_values_list.append(float(enmax_line.split(' = ')[1].split(';')[0])) return max(enmax_values_list)
class Test(TestCase): class_title = 'Structure' data_dir_path = Path.clean(os.path.dirname(__file__), 'data_' + class_title) def setUp(self): self.data_path = Path.clean(self.__class__.data_dir_path) def test_init(self): site = Site() site['position'] = [0.1, 0.2, 0.4, "dir"] site['type'] = 'Ba' site_2 = Site() site_2['position'] = [0.6, 0.22, 0.44, "cart"] site_2['type'] = 'Ti' structure = Structure(lattice=Lattice(a=[3.4, 0.1, 0.2], b=[2.3, 5.0, 0.0], c=[0.0, 0.0, 1.0]), sites=SiteCollection([site, site_2])) self.assertEqual(structure.lattice.to_array(), [[3.4, 0.1, 0.2], [2.3, 5.0, 0.0], [0.0, 0.0, 1.0]]) self.assertEqual(structure.sites.get_sorted_list()[0]['type'], 'Ba') self.assertEqual(structure.sites.get_coordinates_list(), [[0.1, 0.2, 0.4], [0.6, 0.22, 0.44]]) file_path = Path.clean(self.data_path, "poscar_small") structure = Structure(file_path) self.assertEqual(structure.lattice.to_array(), [[5.0, 0.2, 0.1], [0.4, 6.0, 0.7], [-0.2, 0.0, 7.7]]) self.assertEqual( structure.sites.get_sorted_list()[1]['coordinate_mode'], 'Direct') self.assertEqual( structure.get_coordinates_list(), [[0.11, 0.22, 0.33], [0.33, 0.22, 0.11], [0.22, 0.33, 0.11]]) write_file_path = Path.clean(self.data_path, "poscar_small_rewritten") structure.to_poscar_file_path(write_file_path) structure = Structure(write_file_path) self.assertEqual(structure.lattice.to_array(), [[5.0, 0.2, 0.1], [0.4, 6.0, 0.7], [-0.2, 0.0, 7.7]]) self.assertEqual( structure.sites.get_sorted_list()[1]['coordinate_mode'], 'Direct') self.assertEqual( structure.get_coordinates_list(), [[0.11, 0.22, 0.33], [0.33, 0.22, 0.11], [0.22, 0.33, 0.11]]) def test_conversion(self): file_path = Path.clean(self.data_path, "big_posc") structure = Structure(file_path) structure_2 = Structure(file_path) structure_2.convert_sites_to_cartesian_coordinates() structure_2.convert_sites_to_direct_coordinates() print structure for i in range(len(structure.sites)): for j in range(3): self.assertTrue( structure.sites[i]['position'][j] - structure_2.sites[i]['position'][j] < 0.00000000001)