def main(args):
with h5py.File(args.input_path, mode="r") as f:
job_name = list(f.keys())[0]
project_path = os.path.join(os.path.abspath("."), job_name + ".h5")
shutil.copy(args.input_path, project_path)
file = os.path.basename(project_path)
job_name = os.path.splitext(file)[0]
db_project_path = s.top_path(project_path)
project = os.path.dirname(project_path)
db_project = (project + "/")
if db_project_path is not None:
db_project = db_project.replace(db_project_path, "")
job_reload = Project(project).load_from_jobpath(
job_id=None,
db_entry={
"id": 1000,
"status": "",
"chemicalformula": "",
"job": job_name,
"subjob": "/" + job_name,
"projectpath": db_project_path,
"project": db_project,
"hamilton": "",
"hamversion": "",
"parentid": None,
"masterid": None,
},
convert_to_object=True,
)
job_reload.status.initialized = True
job_reload.server.run_mode.modal = True
job_reload.run()
shutil.copy(project_path, args.output_path)
def test_import_from_proj(self):
self.pr.pack(destination_path=self.arch_dir, compress=False)
self.imp_pr.remove_jobs(recursive=True, silently=True)
aux_proj = Project(self.arch_dir) # an auxilary project
aux_proj.open(os.curdir)
self.imp_pr.unpack(aux_proj, compress=False)
path_original = self.pr.path
path_import = self.imp_pr.path
path_original = getdir(path_original)
path_import = getdir(path_import)
compare_obj = dircmp(path_original, path_import)
self.assertEqual(len(compare_obj.diff_files), 0)
def test_Chemical_Element_to_and_from_hdf_with_None_Parent(self):
pr = Project(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
"test_periodic_table"))
basis = CrystalStructure(element="Ni",
bravais_basis="fcc",
lattice_constant=3.7)
ham = pr.create_job(pr.job_type.Lammps, "lammps_test_2")
test_ham = pr.create_job(pr.job_type.Lammps, "lammps_test_2")
ham.structure = basis
ham.to_hdf()
test_ham.from_hdf()
self.assertEqual(test_ham["input/structure/species"][0],
ham["input/structure/species"][0])
ham.remove()
def setUpClass(cls):
cls.count = 12
cls.file_location = os.path.dirname(os.path.abspath(__file__))
cls.project = Project(
os.path.join(cls.file_location, "random_testing_non_modal"))
cls.project.remove_jobs_silently(recursive=True)
cls.project.set_logging_level("INFO")
def setUpClass(cls):
cls.file_location = os.path.dirname(os.path.abspath(__file__))
cls.project = Project(os.path.join(cls.file_location, "test_murnaghan"))
cls.basis = CrystalStructure(
element="Fe", bravais_basis="fcc", lattice_constant=3.5
)
cls.project.remove_jobs_silently(recursive=True)
def setUpClass(cls):
cls.execution_path = os.path.dirname(os.path.abspath(__file__))
cls.project = Project(os.path.join(cls.execution_path, "lammps"))
structure = Atoms(
symbols="Fe2",
positions=np.outer(np.arange(2), np.ones(3)),
cell=2 * np.eye(3),
)
cls.job = Lammps(
project=ProjectHDFio(project=cls.project, file_name="lammps"),
job_name="lammps",
)
cls.job.server.run_mode.interactive = True
cls.job.structure = structure
cls.minimize_job = Lammps(
project=ProjectHDFio(project=cls.project, file_name="lammps"),
job_name="minimize_lammps",
)
cls.minimize_control_job = Lammps(
project=ProjectHDFio(project=cls.project, file_name="lammps"),
job_name="minimize_control_lammps",
)
def setUpClass(cls):
cls.count = 12
cls.file_location = os.path.dirname(os.path.abspath(__file__))
cls.project = Project(os.path.join(cls.file_location,
"random_testing"))
cls.job = cls.project.create_job("ExampleJob", "job_test_run")
cls.job.input["count"] = cls.count
cls.job.run()
def setUpClass(cls):
cls.execution_path = os.path.dirname(os.path.abspath(__file__))
cls.project = Project(os.path.join(cls.execution_path, "test_quickff"))
cls.job = cls.project.create_job("QuickFF", "trial")
cls.job_complete = QuickFF(
project=ProjectHDFio(project=cls.project, file_name="quickff_complete"),
job_name="quickff_complete",
)
def setUpClass(cls):
cls.execution_path = os.path.dirname(os.path.abspath(__file__))
cls.project = Project(os.path.join(cls.execution_path, "lammps"))
cls.job = Lammps(
project=ProjectHDFio(project=cls.project, file_name="lammps"),
job_name="lammps",
)
cls.job_water = Lammps(
project=ProjectHDFio(project=cls.project,
file_name="lammps_water"),
job_name="lammps_water",
)
cls.job_water_dump = Lammps(
project=ProjectHDFio(project=cls.project,
file_name="lammps_water_dump"),
job_name="lammps_water_dump",
)
cls.job_dump = Lammps(
project=ProjectHDFio(project=cls.project,
file_name="lammps_dump_static"),
job_name="lammps_dump_static",
)
cls.job_vcsgc_input = Lammps(
project=ProjectHDFio(project=cls.project,
file_name="lammps_vcsgc_input"),
job_name="lammps_vcsgc_input",
)
cls.minimize_job = Lammps(
project=ProjectHDFio(project=cls.project, file_name="lammps"),
job_name="minimize_lammps",
)
cls.minimize_control_job = Lammps(
project=ProjectHDFio(project=cls.project, file_name="lammps"),
job_name="minimize_control_lammps",
)
cls.md_job = Lammps(
project=ProjectHDFio(project=cls.project, file_name="lammps"),
job_name="md_lammps",
)
cls.md_control_job = Lammps(
project=ProjectHDFio(project=cls.project, file_name="lammps"),
job_name="md_control_lammps",
)
cls.job_read_restart = Lammps(
project=ProjectHDFio(project=cls.project, file_name="lammps"),
job_name="read_restart",
)
cls.job_average = Lammps(
project=ProjectHDFio(project=cls.project, file_name="lammps"),
job_name="average",
)
cls.job_fail = Lammps(
project=ProjectHDFio(project=cls.project, file_name="lammps"),
job_name="fail",
)
def setUpClass(cls):
# this is used to create a folder/a compressed file, are not path
cls.arch_dir = 'archive_folder'
# this is used to create a folder/a compressed file, are not path
cls.arch_dir_comp = cls.arch_dir + '_comp'
cls.pr = Project('test')
cls.pr.remove_jobs(recursive=True, silently=True)
cls.job = cls.pr.create_job(job_type=ToyJob, job_name='toy')
cls.job.run()
cls.pr.pack(destination_path=cls.arch_dir, compress=False)
cls.file_location = os.path.dirname(os.path.abspath(__file__)).replace(
"\\", "/")
def tearDownClass(cls):
project = Project(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
"random_testing"))
job = project.load(project.get_job_ids()[0])
job.remove()
project.remove(enable=True)
def tearDownClass(cls):
# print('tear down')
file_location = os.path.dirname(os.path.abspath(__file__))
project = Project(
os.path.join(file_location, "random_testing_non_modal"))
project.remove_jobs_silently()
project.remove(enable=True)
def setUpClass(cls):
cls.count = 12
cls.file_location = os.path.dirname(os.path.abspath(__file__))
cls.project = Project(
os.path.join(cls.file_location, "random_testing_atomistic"))
cls.job = cls.project.create_job("AtomisticExampleJob",
"job_test_atomistic_run")
cls.job.input["count"] = cls.count
cls.job.structure = Atoms(positions=[[0, 0, 0], [1, 1, 1]],
elements=["Fe", "Fe"],
cell=2 * np.eye(3))
cls.job.interactive_open()
cls.job.run()
def tearDownClass(cls):
cls.job.interactive_close()
project = Project(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
"random_testing_atomistic"))
job = project.load(project.get_job_ids()[0])
job.remove()
project.remove(enable=True)
def main(args):
pr = Project(args.project)
if args.jobs_only:
pr.remove_jobs(recursive=args.recursive, silently=True)
else:
pr.remove(enable=True)
if not os.listdir(args.project):
os.rmdir(args.project)
def main(args):
if args.status:
if "status" not in args.columns:
args.columns = args.columns + ["status"]
if args.since:
if "timestop" not in args.columns:
args.columns = args.columns + ["timestop"]
try:
matches = re.fullmatch("(\d+d)?\w*(\d+h)?\w*(\d+m)?\w*(\d+s)?",
args.since).groups(default="0x")
since = datetime.datetime.now() - datetime.timedelta(
days=int(matches[0][:-1]),
hours=int(matches[1][:-1]),
minutes=int(matches[2][:-1]),
seconds=int(matches[3][:-1]),
)
except AttributeError:
print(
"ERROR: {} is not a proper time delta".format(args.since),
file=sys.stderr,
)
sys.exit(1)
table = Project(args.project).job_table(
full_table=True,
recursive=args.recursive,
columns=args.columns,
all_columns=args.all,
element_lst=args.elements,
job_name_contains=args.name,
)
if len(table) == 0:
sys.exit(0)
mask = [True] * len(table)
if args.status:
mask &= table.loc[:, "status"].isin(args.status)
if args.since:
mask &= table.loc[:, "timestop"] > since
if any(mask):
with pd.option_context("display.expand_frame_repr", False):
print(table[mask])
def setUpClass(cls):
cls.execution_path = os.path.dirname(os.path.abspath(__file__))
cls.project = Project(os.path.join(cls.execution_path, "gpaw"))
atoms = Atoms("Fe1", positions=np.zeros((1, 3)), cell=np.eye(3))
job = Gpaw(
project=ProjectHDFio(project=cls.project, file_name="gpaw"),
job_name="gpaw",
)
job.structure = atoms
job.encut = 300
job.set_kpoints([5, 5, 5])
job.to_hdf()
cls.job = Gpaw(
project=ProjectHDFio(project=cls.project, file_name="gpaw"),
job_name="gpaw",
)
cls.job.from_hdf()
def setUpClass(cls):
cls.execution_path = os.path.dirname(os.path.abspath(__file__))
cls.project = Project(os.path.join(cls.execution_path, "test_vasp"))
cls.job = cls.project.create_job("Vasp", "trial")
cls.job_spin = cls.project.create_job("Vasp", "spin")
cls.job_spin.structure = CrystalStructure("Fe", BravaisBasis="bcc", a=2.83)
cls.job_spin.structure = cls.job_spin.structure.repeat(2)
cls.job_spin.structure[2] = "Se"
cls.job_spin.structure[3] = "O"
cls.job_metadyn = cls.project.create_job("VaspMetadyn", "trial_metadyn")
cls.job_complete = Vasp(
project=ProjectHDFio(project=cls.project, file_name="vasp_complete"),
job_name="vasp_complete",
)
poscar_file = posixpath.join(
cls.execution_path, "../static/vasp_test_files/full_job_sample/POSCAR"
)
cls.job_complete.structure = read_atoms(poscar_file, species_from_potcar=True)
poscar_file = posixpath.join(
cls.execution_path, "../static/vasp_test_files/poscar_samples/POSCAR_metadyn"
)
cls.job_metadyn.structure = read_atoms(poscar_file)
def setUpClass(cls):
cls.file_location = os.path.dirname(os.path.abspath(__file__))
cls.project = Project(
os.path.join(cls.file_location, "interface")
)
cls.project.remove_jobs_silently(recursive=True)
cls.structure = Atoms(
positions=[[0, 0, 0], [1, 1, 1]], elements=["Fe", "Fe"], cell=2 * np.eye(3)
)
cls.temperature = 500.0
cls.cpu_cores = 2
potential = pandas.DataFrame({
'Name': ['Fe Morse'],
'Filename': [[]],
'Model': ['Morse'],
'Species': [['Fe']],
'Config': [['atom_style full\n',
'pair_coeff 1 2 morse 0.019623 1.8860 3.32833\n']]
})
project_dict = {
"job_type": "Lammps",
"project": cls.project,
"potential": potential,
"cpu_cores": cls.cpu_cores
}
cls.job = create_job_template(
job_name="test_fix_iso",
structure=cls.structure,
project_parameter=project_dict
)
cls.job.calc_md(
temperature=cls.temperature,
temperature_damping_timescale=100.0,
pressure=0.0,
pressure_damping_timescale=1000.0
)
def setUpClass(cls):
cls.file_location = os.path.dirname(os.path.abspath(__file__))
cls.project = Project(
os.path.join(cls.file_location, "hessian_class")
)
cls.project.remove_jobs_silently(recursive=True)
cls.job = cls.project.create_job(
"HessianJob", "job_test_hessian"
)
structure = Atoms(
positions=[[0, 0, 0], [1, 1, 1]], elements=["Fe", "Fe"], cell=2 * np.eye(3)
)
cls.job.set_reference_structure(structure)
cls.job.structure.apply_strain(0.01)
cls.job.structure.positions[0, 0] = 0.1
cls.job.structure.center_coordinates_in_unit_cell()
cls.job.set_force_constants(force_constants=1)
cls.job.set_elastic_moduli(bulk_modulus=1, shear_modulus=1)
cls.job.server.run_mode.interactive = True
cls.job.run()
cls.job.structure.positions[0, 1] -= 0.1
cls.job.run()
cls.job.structure.positions[0,1] -= 0.1
cls.job.run()
def tearDownClass(cls):
file_location = os.path.dirname(os.path.abspath(__file__))
project = Project(
os.path.join(file_location, "testing_murnaghan_non_modal"))
project.remove_jobs_silently(recursive=True)
project.remove(enable=True, enforce=True)
"""
pyiron_base<=0.3.10 has a bug that writes all arrays with dtype=object even
numeric ones. As a fix pyiron_base=0.4.1 introduces a conversion when reading
such arrays, but does not automatically save them. This conversion script
simply goes over all jobs and rewrites their HDF5 files, since it's read with
the correct dtype, this then writes this correct dtype.
"""
import sys
from pyiron_base import Project
from pyiron_base.project.update.pyiron_base_03x_to_04x import pyiron_base_03x_to_04x
if __name__ == "__main__":
pr = Project(sys.argv[1])
pyiron_base_03x_to_04x(pr)
from pyiron_base import Project, __version__
pr = Project(
"tests/static/backwards/V{}".format(__version__).replace(".", "_")
)
job = pr.create_job(pr.job_type.ScriptJob, "scriptjob")
# scriptjob requires an existing path, so just set this path, since we don't
# intend on running our selves anyway
job.script_path = __file__
job.input['test_argument'] = 42
job.save()
def tearDownClass(cls):
cls.execution_path = os.path.dirname(os.path.abspath(__file__))
project = Project(os.path.join(cls.execution_path, "lammps"))
project.remove_jobs_silently(recursive=True)
project.remove(enable=True)
def tearDownClass(cls):
file_location = os.path.dirname(os.path.abspath(__file__))
project = Project(os.path.join(file_location, "testing_serial"))
project.remove(enable=True)
def setUpClass(cls):
cls.file_location = os.path.dirname(os.path.abspath(__file__))
cls.project = Project(os.path.join(cls.file_location,
"testing_serial"))
cls.project.remove_jobs_silently(recursive=True)
import sys
from pyiron_base import Project, __version__
pr = Project("tests/static/backwards/")
for job in pr.iter_jobs(recursive=True, convert_to_object=False):
if job.name == "scriptjob":
job = job.to_object()
if job.input.test_argument != 42:
raise ValueError(
"Loading from version {} doesn't restore input.".format(
job.project.path))
def tearDownClass(cls):
cls.file_location = os.path.dirname(os.path.abspath(__file__))
project = Project(os.path.join(cls.file_location, "test_murnaghan"))
project.remove(enable=True, enforce=True)
def setUpClass(cls):
cls.pr = Project('fenics_tutorial_integration')
from pyiron_base import Project, PythonTemplateJob, __version__
class ToyJob(PythonTemplateJob):
def __init__(self, project, job_name):
super(ToyJob, self).__init__(project, job_name)
self.input['input_energy'] = 100
def run_static(self):
with self.project_hdf5.open("output/generic") as h5out:
h5out["energy_tot"] = self.input["input_energy"]
self.status.finished = True
pr = Project("tests/static/backwards/V{}".format(__version__).replace(
".", "_"))
job = pr.create_job(pr.job_type.ToyJob, "toy1")
job.input["input_energy"] = 42
job.run()
job = pr.create_job(pr.job_type.ToyJob, "toy2")
job.input["input_energy"] = 23
job.run()
tab = pr.create_table("toy_table")
tab.add['name'] = lambda j: j.name
tab.run()