further modify pyiron parsers

Author: srmnitc

atomrdf/parsers/pyiron.py

@@ -20,21 +20,154 @@ def ase_to_pyiron(structure):
 
 def extract(job):
     if type(job).__name__ == 'Lammps':
-        return process_job_lammps(job)
+        return lammps_process_job(job)
+    elif type(job).__name__ == 'Calphy':
+        return calphy_process_job(job)
+    elif type(job).__name__ == 'Murnaghan':
+        return murnaghan.process_job(job)
+    elif type(job).__name__ == 'QuasiHarmonicJob':
+        return qha.process_job(job)
+    elif type(job).__name__ == 'Calphy':
+        return calphy.process_job(job)
+    else:
+        raise TypeError("These type of pyiron Job is not currently supported")
+
+
+def lammps_process_job(job):
+    method_dict = Simulation.template()
+    _lammps_identify_method(job, method_dict)
+    _lammps_add_software(method_dict)
+    _lammps_get_simulation_folder(job, method_dict)
+    _lammps_extract_calculated_quantities(job, method_dict)
+    _lammps_get_structures(job, method_dict)
+    return method_dict
 
-def process_job_lammps(job):
+def calphy_process_job(job):
     method_dict = Simulation.template()
-    identify_method(job, method_dict)
-    add_software(method_dict)
-    get_simulation_folder(job, method_dict)
-    extract_calculated_quantities(job, method_dict)
-    get_structures(job, method_dict)
+    _calphy_identify_method(job, method_dict)
+    _calphy_add_software(method_dict)
+    _lammps_get_simulation_folder(job, method_dict)
+    _calphy_extract_calculated_quantities(job, method_dict)
+    _lammps_get_structures(job, method_dict)
     return method_dict
 
-def get_simulation_folder(job, method_dict):
+def murnaghan_process_job(job):
+    #murnaghan job processing; add individual lammps jobs first
+    job_dicts = []
+    for jobid in job.child_ids:
+        child_job = job.project.load(jobid)
+        if type(child_job).__name__ == 'Lammps':
+            single_job_dict = lammps_process_job(child_job)
+            #note that we turn the jobs to child here
+            job_dicts.append(single_job_dict)
+    
+    #create an additional jobdict with the murnaghan job
+    murnaghan_dict = Simulation.template()
+    _lammps_get_structures(job, murnaghan_dict)
+    _lammps_get_simulation_folder(job, murnaghan_dict)
+
+    #add the murnaghan method
+    murnaghan_dict['method'] = "EquationOfStateFit"
+    outputs = []
+    outputs.append(
+        {
+            "label": "EquilibriumEnergy",
+            "value": np.round(job['output/equilibrium_energy'], decimals=4),
+            "unit": "EV",
+            "associate_to_sample": True,
+            "basename": "TotalEnergy",
+        }
+    )
+    outputs.append(
+        {
+            "label": "EquilibriumVolume",
+            "value": np.round(job['output/equilibrium_volume'], decimals=4),
+            "unit": "ANGSTROM3",
+            "associate_to_sample": True,
+            "basename": "Volume",
+        }
+    )
+    outputs.append(
+        {
+            "label": "TotalEnergy",
+            "value": np.round(job['output/energy'], decimals=4),
+            "unit": "EV",
+            "associate_to_sample": True,
+            "basename": "TotalEnergy",
+        }
+    )
+    outputs.append(
+        {
+            "label": "SimulationCellVolume",
+            "value": np.round(job['output/volume'], decimals=4),
+            "unit": "ANGSTROM3",
+            "associate_to_sample": True,
+            "basename": "SimulationCellVolume",
+        }
+    )
+    outputs.append(
+        {
+            "label": "BulkModulus",
+            'basename': "BulkModulus",
+            "value": np.round(job['output/equilibrium_bulk_modulus'], decimals=2),
+            "unit": "GigaPA",
+            "associate_to_sample": True,
+        }
+    )
+    
+    murnaghan_dict['calculated_property'] = outputs
+    _lammps_add_software(murnaghan_dict)
+    job_dicts.append(murnaghan_dict)
+    return job_dicts
+
+def quasiharmonic_process_job(job):
+    #murnaghan job processing; add individual lammps jobs first
+    job_dicts = []
+    
+    #create an additional jobdict with the murnaghan job
+    quasi_dict = Simulation.template()
+    _lammps_get_structures(job, quasi_dict)
+    _lammps_get_simulation_folder(job, quasi_dict)
+
+    #add the murnaghan method
+    quasi_dict['method'] = "QuasiHarmonicApproximation"
+    outputs = []
+    outputs.append(
+        {
+            "label": "QuasiharmonicFreeEnergy",
+            "value": np.round(job['output/free_energy'].T, decimals=4),
+            "unit": "EV",
+            "associate_to_sample": True,
+            "basename": "FreeEnergy",
+        }
+    )
+    outputs.append(
+        {
+            "label": "QuasiharmonicVolume",
+            "value": np.round(job['output/volumes'].T, decimals=4),
+            "unit": "ANGSTROM3",
+            "associate_to_sample": True,
+            "basename": "SimulationCellVolume",
+        }
+    )
+    outputs.append(
+        {
+            "label": "QuasiharmonicTemperature",
+            "value": np.round(job['output/temperatures'][0], decimals=2),
+            "unit": "K",
+            "associate_to_sample": True,
+            "basename": "Temperature",
+        }
+    )
+    quasi_dict['calculated_property'] = outputs
+    _lammps_add_software(quasi_dict)
+    job_dicts.append(quasi_dict)
+    return job_dicts
+
+def _lammps_get_simulation_folder(job, method_dict):
     method_dict['path'] = os.path.join(job.project.path, f'{job.name}_hdf5')
 
-def identify_method(job, method_dict):
+def _lammps_identify_method(job, method_dict):
     job_dict = job.input.to_dict()
     input_dict = {
         job_dict["control_inp/data_dict"]["Parameter"][x]: job_dict[
@@ -134,7 +267,7 @@ def identify_method(job, method_dict):
             }
         )
 
-def add_software(method_dict):
+def _lammps_add_software(method_dict):
     method_dict["workflow_manager"] = {}
     method_dict["workflow_manager"]["uri"] = "https://doi.org/10.1016/j.commatsci.2018.07.043"
     method_dict["workflow_manager"]["label"] = "pyiron"
@@ -146,7 +279,7 @@ def add_software(method_dict):
     }
     method_dict["software"] = [software]
 
-def extract_calculated_quantities(job, method_dict):
+def _lammps_extract_calculated_quantities(job, method_dict):
     """
     Extracts calculated quantities from a job.
 
@@ -207,9 +340,136 @@ def extract_calculated_quantities(job, method_dict):
 
     method_dict['calculated_property'] =  outputs
 
-def get_structures(job, method_dict):
+def _lammps_get_structures(job, method_dict):
     initial_pyiron_structure = job.structure
     final_pyiron_structure = job.get_structure(frame=-1)
 
     method_dict['initial_sample'] = initial_pyiron_structure
-    method_dict['final_sample'] = final_pyiron_structure    
+    method_dict['final_sample'] = final_pyiron_structure    
+
+
+def _calphy_identify_method(job, method_dict):
+    pressure = job.input.pressure
+    if pressure is None:
+        iso = True
+        fix_lattice = True
+    elif np.isscalar(pressure):
+        iso = True
+        fix_lattice = False
+    elif np.shape(pressure) == (1,):
+        iso = True
+        fix_lattice = False
+    elif np.shape(pressure) == (2,):
+        iso = True
+        fix_lattice = False
+    elif np.shape(pressure) == (1, 3):
+        iso = False
+        fix_lattice = False
+    elif np.shape(pressure) == (2, 3):
+        iso = False
+        fix_lattice = False
+    
+    dof = []
+    dof.append("AtomicPositionRelaxation")
+    ensemble = 'IsothermalIsobaricEnsemble'
+
+    if not fix_lattice:
+        dof.append("CellVolumeRelaxation")
+        ensemble = "CanonicalEnsemble"
+
+    if not iso:
+        dof.append("CellShapeRelaxation")
+
+    method_dict["method"] = {'basename': 'ThermodynamicIntegration'}
+    method_dict["degrees_of_freedom"] = dof
+    method_dict["thermodynamic_ensemble"] = {'basename': ensemble}
+
+    # now process potential
+    inpdict = job.input.to_dict()
+    ps = inpdict["potential_inp/data_dict"]["Value"][0]
+    name = inpdict["potential_inp/potential/Name"]
+    potstr = job.input.to_dict()["potential_inp/potential/Citations"]
+    potdict = ast.literal_eval(potstr[1:-1])
+    url = None
+    if "url" in potdict[list(potdict.keys())[0]].keys():
+        url = potdict[list(potdict.keys())[0]]["url"]
+
+    pssplit = ps.split('/')
+    if len(pssplit) > 1:
+        ps = pssplit[0]
+
+    method_dict["interatomic_potential"] = {
+        'potential_type': ps,
+    }
+
+    if url is not None:
+        method_dict["interatomic_potential"]["uri"] = url
+    else:
+        method_dict["interatomic_potential"]["uri"] = name
+
+    #add temperature and pressure as inputs
+    method_dict['input_parameter'].append(
+        {
+            "basename": "Temperature",
+            "label": "Temperature",
+            "value": job.input.temperature,
+            "unit": "K",
+        }
+    )
+
+    method_dict['input_parameter'].append(
+        {
+            "basename": "Pressure",
+            "label": "Pressure",
+            "value": job.input.pressure,
+            "unit": "GigaPA",
+        }
+    )
+
+def _calphy_add_software(method_dict):
+    method_dict["workflow_manager"] = {}
+    method_dict["workflow_manager"]["uri"] = "https://doi.org/10.1016/j.commatsci.2018.07.043"
+    method_dict["workflow_manager"]["label"] = "pyiron"
+    # and finally code details
+
+    software1 = {
+        "uri": "https://doi.org/10.1016/j.cpc.2021.108171",
+        "label": "LAMMPS",
+    }
+    software2 = {
+        "uri": "https://doi.org/10.5281/zenodo.10527452",
+        "label": "Calphy",
+    }
+    method_dict["software"] = [software1, software2]
+
+def _calphy_extract_calculated_quantities(job, method_dict):
+
+    outputs = []
+    outputs.append(
+        {
+            "label": "FreeEnergy",
+            "basename": "FreeEnergy",
+            "value": np.round(job['output/energy_free'], decimals=4),
+            "unit": "EV",
+            "associate_to_sample": True,
+        }
+    )
+    outputs.append(
+        {
+            "label": "VirialPressure",
+            "basename": "VirialPressure",
+            "value": np.round(job['output/pressure'], decimals=4),
+            "unit": "GigaPA",
+            "associate_to_sample": True,
+        }
+    )
+    outputs.append(
+        {
+            "label": "Temperature",
+            "basename": "Temperature",
+            "value": np.round(job['output/temperature'], decimals=2),
+            "unit": "K",
+            "associate_to_sample": True,
+        }
+    )  
+    method_dict['calculated_property'] =  outputs