Replace dataclass by abstract class

atomistics/calculators/ase.py

@@ -25,43 +25,54 @@
     from atomistics.calculators.interface import TaskName
 
 
-class ASEExecutor(object):
+class ASEOutput(OutputStatic, OutputMolecularDynamics):
     def __init__(self, ase_structure, ase_calculator):
         self.structure = ase_structure
         self.structure.calc = ase_calculator
 
+    @property
     def forces(self):
         return self.structure.get_forces()
 
+    @property
     def energy(self):
         return self.structure.get_potential_energy()
 
+    @property
     def energy_pot(self):
         return self.structure.get_potential_energy()
 
+    @property
     def energy_tot(self):
         return (
             self.structure.get_potential_energy() + self.structure.get_kinetic_energy()
         )
 
+    @property
     def stress(self):
         return self.structure.get_stress(voigt=False)
 
+    @property
     def pressure(self):
         return self.structure.get_stress(voigt=False)
 
+    @property
     def cell(self):
         return self.structure.get_cell()
 
+    @property
     def positions(self):
         return self.structure.get_positions()
 
+    @property
     def velocities(self):
         return self.structure.get_velocities()
 
+    @property
     def temperature(self):
         return self.structure.get_temperature()
 
+    @property
     def volume(self):
         return self.structure.get_volume()
 
@@ -107,11 +118,8 @@ def calc_static_with_ase(
     ase_calculator,
     output_keys=OutputStatic.keys(),
 ):
-    return OutputStatic(
-        **{k: getattr(ASEExecutor, k) for k in OutputStatic.keys()}
-    ).get(
-        ASEExecutor(ase_structure=structure, ase_calculator=ase_calculator),
-        *output_keys,
+    return ASEOutput(ase_structure=structure, ase_calculator=ase_calculator).get_output(
+        output_keys=output_keys
     )
 
 
@@ -120,16 +128,12 @@ def _calc_md_step_with_ase(
 ):
     structure.calc = ase_calculator
     MaxwellBoltzmannDistribution(atoms=structure, temperature_K=temperature)
-    ASEOutputMolecularDynamics = OutputMolecularDynamics(
-        **{k: getattr(ASEExecutor, k) for k in OutputMolecularDynamics.keys()}
-    )
     cache = {q: [] for q in output_keys}
     for i in range(int(run / thermo)):
         dyn.run(thermo)
-        calc_dict = ASEOutputMolecularDynamics.get(
-            ASEExecutor(ase_structure=structure, ase_calculator=ase_calculator),
-            *output_keys,
-        )
+        calc_dict = ASEOutput(
+            ase_structure=structure, ase_calculator=ase_calculator
+        ).get_output(output_keys=output_keys)
         for k, v in calc_dict.items():
             cache[k].append(v)
     return {q: np.array(cache[q]) for q in output_keys}

atomistics/calculators/lammps/calculator.py

@@ -7,6 +7,7 @@
 from pylammpsmpi import LammpsASELibrary
 
 from atomistics.calculators.interface import get_quantities_from_tasks
+from atomistics.calculators.lammps.output import LammpsOutput
 from atomistics.calculators.lammps.helpers import (
     lammps_calc_md,
     lammps_run,
@@ -28,9 +29,11 @@
     LAMMPS_MINIMIZE_VOLUME,
 )
 from atomistics.calculators.wrapper import as_task_dict_evaluator
-from atomistics.shared.thermal_expansion import OutputThermalExpansion
-from atomistics.shared.output import OutputStatic, OutputMolecularDynamics
-
+from atomistics.shared.output import (
+    OutputStatic,
+    OutputMolecularDynamics,
+    OutputThermalExpansion,
+)
 
 if TYPE_CHECKING:
     from ase import Atoms
@@ -132,12 +135,7 @@ def calc_static_with_lammps(
         lmp=lmp,
         **kwargs,
     )
-    result_dict = OutputStatic(
-        forces=LammpsASELibrary.interactive_forces_getter,
-        energy=LammpsASELibrary.interactive_energy_pot_getter,
-        stress=LammpsASELibrary.interactive_pressures_getter,
-        volume=LammpsASELibrary.interactive_volume_getter,
-    ).get(lmp_instance, *output_keys)
+    result_dict = LammpsOutput(lmp=lmp_instance).get_output(output_keys=output_keys)
     lammps_shutdown(lmp_instance=lmp_instance, close_instance=lmp is None)
     return result_dict
 

atomistics/calculators/lammps/helpers.py

@@ -5,9 +5,13 @@
 from pylammpsmpi import LammpsASELibrary
 
 from atomistics.calculators.lammps.potential import validate_potential_dataframe
+from atomistics.calculators.lammps.output import LammpsOutput
+from atomistics.shared.output import (
+    OutputMolecularDynamics,
+    OutputThermalExpansion,
+)
 from atomistics.shared.thermal_expansion import get_thermal_expansion_output
 from atomistics.shared.tqdm_iterator import get_tqdm_iterator
-from atomistics.shared.output import OutputMolecularDynamics, OutputThermalExpansion
 
 
 def lammps_run(structure, potential_dataframe, input_template=None, lmp=None, **kwargs):
@@ -47,17 +51,7 @@ def lammps_calc_md_step(
 ):
     run_str_rendered = Template(run_str).render(run=run)
     lmp_instance.interactive_lib_command(run_str_rendered)
-    return OutputMolecularDynamics(
-        positions=LammpsASELibrary.interactive_positions_getter,
-        cell=LammpsASELibrary.interactive_cells_getter,
-        forces=LammpsASELibrary.interactive_forces_getter,
-        temperature=LammpsASELibrary.interactive_temperatures_getter,
-        energy_pot=LammpsASELibrary.interactive_energy_pot_getter,
-        energy_tot=LammpsASELibrary.interactive_energy_tot_getter,
-        pressure=LammpsASELibrary.interactive_pressures_getter,
-        velocities=LammpsASELibrary.interactive_velocities_getter,
-        volume=LammpsASELibrary.interactive_volume_getter,
-    ).get(lmp_instance, *output_keys)
+    return LammpsOutput(lmp=lmp_instance).get_output(output_keys=output_keys)
 
 
 def lammps_calc_md(

atomistics/calculators/lammps/output.py

@@ -0,0 +1,50 @@
+from atomistics.shared.output import OutputMolecularDynamics, OutputStatic
+
+
+class LammpsOutput(OutputMolecularDynamics, OutputStatic):
+    def __init__(self, lmp):
+        self._lmp = lmp
+
+    @property
+    def forces(self):
+        return self._lmp.interactive_forces_getter()
+
+    @property
+    def energy(self):
+        return self._lmp.interactive_energy_pot_getter()
+
+    @property
+    def stress(self):
+        return self._lmp.interactive_pressures_getter()
+
+    @property
+    def volume(self):
+        return self._lmp.interactive_volume_getter()
+
+    @property
+    def positions(self):
+        return self._lmp.interactive_positions_getter()
+
+    @property
+    def cell(self):
+        return self._lmp.interactive_cells_getter()
+
+    @property
+    def temperature(self):
+        return self._lmp.interactive_temperatures_getter()
+
+    @property
+    def energy_pot(self):
+        return self._lmp.interactive_energy_pot_getter()
+
+    @property
+    def energy_tot(self):
+        return self._lmp.interactive_energy_tot_getter()
+
+    @property
+    def pressure(self):
+        return self._lmp.interactive_pressures_getter()
+
+    @property
+    def velocities(self):
+        return self._lmp.interactive_velocities_getter()

atomistics/calculators/qe.py

@@ -9,19 +9,23 @@
 from atomistics.calculators.wrapper import as_task_dict_evaluator
 
 
-class QEStaticParser(object):
+class QEOutputStatic(OutputStatic):
     def __init__(self, filename):
         self.parser = io.read_pw_scf(filename=filename, use_alat=True)
 
+    @property
     def forces(self):
         return self.parser.forces
 
+    @property
     def energy(self):
         return self.parser.etot
 
+    @property
     def stress(self):
         return self.parser.stress
 
+    @property
     def volume(self):
         return self.parser.volume
 
@@ -207,9 +211,7 @@ def calc_static_with_qe(
     call_qe_via_ase_command(
         calculation_name=calculation_name, working_directory=working_directory
     )
-    return OutputStatic(
-        **{k: getattr(QEStaticParser, k) for k in OutputStatic.keys()}
-    ).get(QEStaticParser(filename=output_file_name), *output_keys)
+    return QEOutputStatic(filename=output_file_name).get_output(output_keys=output_keys)
 
 
 @as_task_dict_evaluator