From aad18e18cf517af70b1294c102050f4ea5cc1037 Mon Sep 17 00:00:00 2001
From: Jan Janssen <janssen@mpie.de>
Date: Tue, 28 Nov 2023 13:10:33 +0100
Subject: [PATCH 1/5] Add thermal expansion example for LAMMPS

---
 atomistics/calculators/interface.py           |   2 +
 atomistics/calculators/lammps/calculator.py   | 133 ++++++++++++++----
 atomistics/calculators/lammps/commands.py     |  26 ++++
 atomistics/workflows/__init__.py              |   3 +
 .../workflows/molecular_dynamics/__init__.py  |   0
 .../workflows/molecular_dynamics/workflow.py  |   2 +
 ...cular_dynamics_thermal_expansion_lammps.py |  42 ++++++
 7 files changed, 177 insertions(+), 31 deletions(-)
 create mode 100644 atomistics/calculators/lammps/commands.py
 create mode 100644 atomistics/workflows/molecular_dynamics/__init__.py
 create mode 100644 atomistics/workflows/molecular_dynamics/workflow.py
 create mode 100644 tests/test_molecular_dynamics_thermal_expansion_lammps.py

diff --git a/atomistics/calculators/interface.py b/atomistics/calculators/interface.py
index 76289de3..660544e9 100644
--- a/atomistics/calculators/interface.py
+++ b/atomistics/calculators/interface.py
@@ -19,6 +19,7 @@ class TaskEnum(StrEnum):
     calc_forces = "calc_forces"
     optimize_positions = "optimize_positions"
     optimize_positions_and_volume = "optimize_positions_and_volume"
+    calc_molecular_dynamics_thermal_expansion = "calc_molecular_dynamics_thermal_expansion"
 
 
 class TaskOutputEnum(Enum):
@@ -26,6 +27,7 @@ class TaskOutputEnum(Enum):
     forces = "calc_forces"
     structure_with_optimized_positions = "optimize_positions"
     structure_with_optimized_positions_and_volume = "optimize_positions_and_volume"
+    volume_over_temperature = "calc_molecular_dynamics_thermal_expansion"
 
 
 if TYPE_CHECKING:
diff --git a/atomistics/calculators/lammps/calculator.py b/atomistics/calculators/lammps/calculator.py
index 8535ed6c..948c9159 100644
--- a/atomistics/calculators/lammps/calculator.py
+++ b/atomistics/calculators/lammps/calculator.py
@@ -3,10 +3,21 @@
 from typing import TYPE_CHECKING
 
 from jinja2 import Template
+import numpy as np
 import pandas
 from pylammpsmpi import LammpsASELibrary
 
 from atomistics.calculators.wrapper import as_task_dict_evaluator
+from atomistics.calculators.lammps.commands import (
+    LAMMPS_THERMO_STYLE,
+    LAMMPS_THERMO,
+    LAMMPS_ENSEMBLE_NPT,
+    LAMMPS_VELOCITY,
+    LAMMPS_TIMESTEP,
+    LAMMPS_MINIMIZE,
+    LAMMPS_RUN,
+    LAMMPS_MINIMIZE_VOLUME,
+)
 
 if TYPE_CHECKING:
     from ase import Atoms
@@ -15,42 +26,77 @@
     from atomistics.calculators.interface import TaskName
 
 
-LAMMPS_STATIC_RUN_INPUT_TEMPLATE = """\
-thermo_style custom step temp pe etotal pxx pxy pxz pyy pyz pzz vol
-thermo_modify format float %20.15g
-thermo 100
-run 0"""
-
-
-LAMMPS_MINIMIZE_POSITIONS_INPUT_TEMPLATE = """\
-thermo_style custom step temp pe etotal pxx pxy pxz pyy pyz pzz vol
-thermo_modify format float %20.15g
-thermo 10
-min_style {{min_style}}
-minimize {{etol}} {{ftol}} {{maxiter}} {{maxeval}}"""
-
-
-LAMMPS_MINIMIZE_POSITIONS_AND_VOLUME_INPUT_TEMPLATE = """\
-fix ensemble all box/relax iso 0.0
-thermo_style custom step temp pe etotal pxx pxy pxz pyy pyz pzz vol
-thermo_modify format float %20.15g
-thermo 10
-min_style {{min_style}}
-minimize {{etol}} {{ftol}} {{maxiter}} {{maxeval}}"""
-
-
-def template_render(
+def template_render_minimize(
     template_str,
     min_style="cg",
     etol=0.0,
     ftol=0.0001,
     maxiter=100000,
     maxeval=10000000,
+    thermo=10,
 ):
     return Template(template_str).render(
-        min_style=min_style, etol=etol, ftol=ftol, maxiter=maxiter, maxeval=maxeval
+        min_style=min_style,
+        etol=etol,
+        ftol=ftol,
+        maxiter=maxiter,
+        maxeval=maxeval,
+        thermo=thermo,
+    )
+
+
+def template_render_run(
+    template_str,
+    run=0,
+    thermo=100,
+):
+    return Template(template_str).render(
+        run=run,
+        thermo=thermo,
+    )
+
+
+def calc_thermal_expansion_md(
+    structure, potential_dataframe, lmp, Tstart=15, Tstop=1500, Tstep=5
+):
+    init_str = (
+        LAMMPS_THERMO_STYLE
+        + "\n"
+        + LAMMPS_TIMESTEP
+        + "\n"
+        + LAMMPS_THERMO
+        + "\n"
+        + LAMMPS_VELOCITY
+        + "\n"
+    )
+    run_str = LAMMPS_ENSEMBLE_NPT + "\n" + LAMMPS_RUN
+
+    lmp = _run_simulation(
+        structure=structure,
+        potential_dataframe=potential_dataframe,
+        input_template=Template(init_str).render(
+            thermo=100, temp=Tstart, timestep=0.001, seed=4928459, dist="gaussian"
+        ),
+        lmp=lmp,
     )
 
+    volume_md_lst = []
+    temperature_lst = np.arange(Tstart, Tstop + Tstep, Tstep).tolist()
+    for temp in temperature_lst:
+        run_str_rendered = Template(run_str).render(
+            run=100,
+            Tstart=temp - 5,
+            Tstop=temp,
+            Tdamp=0.1,
+            Pstart=0.0,
+            Pstop=0.0,
+            Pdamp=1.0,
+        )
+        for l in run_str_rendered.split("\n"):
+            lmp.interactive_lib_command(l)
+        volume_md_lst.append(lmp.interactive_volume_getter())
+    return temperature_lst, volume_md_lst
+
 
 @as_task_dict_evaluator
 def evaluate_with_lammps_library(
@@ -62,11 +108,20 @@ def evaluate_with_lammps_library(
 ):
     results = {}
     if "optimize_positions_and_volume" in tasks:
+        template_str = (
+            LAMMPS_MINIMIZE_VOLUME
+            + "\n"
+            + LAMMPS_THERMO_STYLE
+            + "\n"
+            + LAMMPS_THERMO
+            + "\n"
+            + LAMMPS_MINIMIZE
+        )
         lmp = _run_simulation(
             structure=structure,
             potential_dataframe=potential_dataframe,
-            input_template=template_render(
-                template_str=LAMMPS_MINIMIZE_POSITIONS_AND_VOLUME_INPUT_TEMPLATE,
+            input_template=template_render_minimize(
+                template_str=template_str,
                 **lmp_optimizer_kwargs,
             ),
             lmp=lmp,
@@ -76,11 +131,14 @@ def evaluate_with_lammps_library(
         structure_copy.positions = lmp.interactive_positions_getter()
         results["structure_with_optimized_positions_and_volume"] = structure_copy
     elif "optimize_positions" in tasks:
+        template_str = (
+            LAMMPS_THERMO_STYLE + "\n" + LAMMPS_THERMO + "\n" + LAMMPS_MINIMIZE
+        )
         lmp = _run_simulation(
             structure=structure,
             potential_dataframe=potential_dataframe,
-            input_template=template_render(
-                template_str=LAMMPS_MINIMIZE_POSITIONS_INPUT_TEMPLATE,
+            input_template=template_render_minimize(
+                template_str=template_str,
                 **lmp_optimizer_kwargs,
             ),
             lmp=lmp,
@@ -88,11 +146,24 @@ def evaluate_with_lammps_library(
         structure_copy = structure.copy()
         structure_copy.positions = lmp.interactive_positions_getter()
         results["structure_with_optimized_positions"] = structure_copy
+    elif "calc_molecular_dynamics_thermal_expansion" in tasks:
+        temperature_lst, volume_md_lst = calc_thermal_expansion_md(
+            structure=structure,
+            potential_dataframe=potential_dataframe,
+            lmp=lmp,
+            **lmp_optimizer_kwargs,
+        )
+        results["volume_over_temperature"] = (temperature_lst, volume_md_lst)
     elif "calc_energy" in tasks or "calc_forces" in tasks:
+        template_str = LAMMPS_THERMO_STYLE + "\n" + LAMMPS_THERMO + "\n" + LAMMPS_RUN
         lmp = _run_simulation(
             structure=structure,
             potential_dataframe=potential_dataframe,
-            input_template=LAMMPS_STATIC_RUN_INPUT_TEMPLATE,
+            input_template=template_render_run(
+                template_str=template_str,
+                thermo=100,
+                run=0,
+            ),
             lmp=lmp,
         )
         if "calc_energy" in tasks:
diff --git a/atomistics/calculators/lammps/commands.py b/atomistics/calculators/lammps/commands.py
new file mode 100644
index 00000000..971d7103
--- /dev/null
+++ b/atomistics/calculators/lammps/commands.py
@@ -0,0 +1,26 @@
+LAMMPS_THERMO_STYLE = """\
+thermo_style custom step temp pe etotal pxx pxy pxz pyy pyz pzz vol
+thermo_modify format float %20.15g"""
+
+
+LAMMPS_THERMO = "thermo {{thermo}}"
+
+
+LAMMPS_RUN = "run {{run}}"
+
+
+LAMMPS_MINIMIZE = """\
+min_style {{min_style}}
+minimize {{etol}} {{ftol}} {{maxiter}} {{maxeval}}"""
+
+
+LAMMPS_MINIMIZE_VOLUME = "fix ensemble all box/relax iso 0.0"
+
+
+LAMMPS_TIMESTEP = "timestep {{timestep}}"
+
+
+LAMMPS_VELOCITY = "velocity all create $(2 * {{ temp }}) {{seed}} dist {{dist}}"
+
+
+LAMMPS_ENSEMBLE_NPT = "fix ensemble all npt temp {{Tstart}} {{Tstop}} {{Tdamp}} iso {{Pstart}} {{Pstop}} {{Pdamp}}"
diff --git a/atomistics/workflows/__init__.py b/atomistics/workflows/__init__.py
index 1775358f..f9104b6b 100644
--- a/atomistics/workflows/__init__.py
+++ b/atomistics/workflows/__init__.py
@@ -1,6 +1,9 @@
 from atomistics.workflows.elastic.workflow import ElasticMatrixWorkflow
 from atomistics.workflows.evcurve.workflow import EnergyVolumeCurveWorkflow
 from atomistics.workflows.langevin.workflow import LangevinWorkflow
+from atomistics.workflows.molecular_dynamics.workflow import (
+    calc_molecular_dynamics_thermal_expansion
+)
 from atomistics.workflows.structure_optimization.workflow import (
     optimize_positions,
     optimize_positions_and_volume,
diff --git a/atomistics/workflows/molecular_dynamics/__init__.py b/atomistics/workflows/molecular_dynamics/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/atomistics/workflows/molecular_dynamics/workflow.py b/atomistics/workflows/molecular_dynamics/workflow.py
new file mode 100644
index 00000000..2bb26160
--- /dev/null
+++ b/atomistics/workflows/molecular_dynamics/workflow.py
@@ -0,0 +1,2 @@
+def calc_molecular_dynamics_thermal_expansion(structure):
+    return {"calc_molecular_dynamics_thermal_expansion": structure}
\ No newline at end of file
diff --git a/tests/test_molecular_dynamics_thermal_expansion_lammps.py b/tests/test_molecular_dynamics_thermal_expansion_lammps.py
new file mode 100644
index 00000000..96030f9f
--- /dev/null
+++ b/tests/test_molecular_dynamics_thermal_expansion_lammps.py
@@ -0,0 +1,42 @@
+import os
+
+from ase.build import bulk
+import unittest
+
+from atomistics.workflows import calc_molecular_dynamics_thermal_expansion
+
+
+try:
+    from atomistics.calculators import (
+        evaluate_with_lammps, get_potential_by_name
+    )
+
+    skip_lammps_test = False
+except ImportError:
+    skip_lammps_test = True
+
+
+@unittest.skipIf(
+    skip_lammps_test, "LAMMPS is not installed, so the LAMMPS tests are skipped."
+)
+class TestMolecularDynamicsThermalExpansion(unittest.TestCase):
+    def test_calc_thermal_expansion(self):
+        structure = bulk("Al", cubic=True)
+        df_pot_selected = get_potential_by_name(
+            potential_name='1999--Mishin-Y--Al--LAMMPS--ipr1',
+            resource_path=os.path.join(os.path.dirname(__file__), "static", "lammps"),
+        )
+        task_dict = calc_molecular_dynamics_thermal_expansion(structure=structure)
+        result_dict = evaluate_with_lammps(
+            task_dict=task_dict,
+            potential_dataframe=df_pot_selected,
+            lmp_optimizer_kwargs={
+                "Tstart": 50,
+                "Tstop": 500,
+                "Tstep": 50,
+            }
+        )
+        temperature_lst = result_dict['volume_over_temperature'][0]
+        volume_lst = result_dict['volume_over_temperature'][0]
+        self.assertEqual(temperature_lst, [50, 100, 150, 200, 250, 300, 350, 400, 450, 500])
+        self.assertTrue(volume_lst[0] < volume_lst[-1])

From cd9d52e3d8cb35a12b0b51614560b1474fcffc25 Mon Sep 17 00:00:00 2001
From: Jan Janssen <janssen@mpie.de>
Date: Tue, 28 Nov 2023 17:51:10 +0100
Subject: [PATCH 2/5] Use more functional workflows

---
 atomistics/calculators/__init__.py            |  1 +
 atomistics/calculators/interface.py           |  4 +-
 atomistics/calculators/lammps/__init__.py     |  1 +
 atomistics/calculators/lammps/calculator.py   | 37 ++++++---------
 atomistics/calculators/lammps/helpers.py      | 45 ++++++++++++++-----
 atomistics/workflows/__init__.py              |  2 +-
 .../workflows/molecular_dynamics/workflow.py  |  2 +-
 ...cular_dynamics_thermal_expansion_lammps.py | 25 +++++++++--
 8 files changed, 76 insertions(+), 41 deletions(-)

diff --git a/atomistics/calculators/__init__.py b/atomistics/calculators/__init__.py
index 9c79a2e2..b08517e2 100644
--- a/atomistics/calculators/__init__.py
+++ b/atomistics/calculators/__init__.py
@@ -11,6 +11,7 @@
         calc_energy_and_forces_with_lammps,
         calc_energy_with_lammps,
         calc_forces_with_lammps,
+        calc_molecular_dynamics_thermal_expansion_with_lammps,
         evaluate_with_lammps,
         evaluate_with_lammps_library,
         get_potential_dataframe,
diff --git a/atomistics/calculators/interface.py b/atomistics/calculators/interface.py
index 660544e9..c73f7640 100644
--- a/atomistics/calculators/interface.py
+++ b/atomistics/calculators/interface.py
@@ -19,7 +19,9 @@ class TaskEnum(StrEnum):
     calc_forces = "calc_forces"
     optimize_positions = "optimize_positions"
     optimize_positions_and_volume = "optimize_positions_and_volume"
-    calc_molecular_dynamics_thermal_expansion = "calc_molecular_dynamics_thermal_expansion"
+    calc_molecular_dynamics_thermal_expansion = (
+        "calc_molecular_dynamics_thermal_expansion"
+    )
 
 
 class TaskOutputEnum(Enum):
diff --git a/atomistics/calculators/lammps/__init__.py b/atomistics/calculators/lammps/__init__.py
index 951532d0..23728d87 100644
--- a/atomistics/calculators/lammps/__init__.py
+++ b/atomistics/calculators/lammps/__init__.py
@@ -2,6 +2,7 @@
     calc_energy_and_forces_with_lammps,
     calc_energy_with_lammps,
     calc_forces_with_lammps,
+    calc_molecular_dynamics_thermal_expansion_with_lammps,
     evaluate_with_lammps,
     evaluate_with_lammps_library,
     optimize_positions_and_volume_with_lammps,
diff --git a/atomistics/calculators/lammps/calculator.py b/atomistics/calculators/lammps/calculator.py
index 03cc40fc..481a5f18 100644
--- a/atomistics/calculators/lammps/calculator.py
+++ b/atomistics/calculators/lammps/calculator.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import numpy as np
 from typing import TYPE_CHECKING
 
 from pylammpsmpi import LammpsASELibrary
@@ -7,6 +8,7 @@
 from atomistics.calculators.wrapper import as_task_dict_evaluator
 from atomistics.calculators.lammps.helpers import (
     lammps_run,
+    lammps_thermal_expansion_loop,
     lammps_shutdown,
     template_render_minimize,
     template_render_run,
@@ -156,8 +158,8 @@ def optimize_positions_with_lammps(
     return structure_copy
 
 
-def calc_thermal_expansion_md(
-    structure, potential_dataframe, lmp, Tstart=15, Tstop=1500, Tstep=5
+def calc_molecular_dynamics_thermal_expansion_with_lammps(
+    structure, potential_dataframe, Tstart=15, Tstop=1500, Tstep=5, lmp=None
 ):
     init_str = (
         LAMMPS_THERMO_STYLE
@@ -170,31 +172,15 @@ def calc_thermal_expansion_md(
         + "\n"
     )
     run_str = LAMMPS_ENSEMBLE_NPT + "\n" + LAMMPS_RUN
-
-    lmp = _run_simulation(
+    temperature_lst = np.arange(Tstart, Tstop + Tstep, Tstep).tolist()
+    volume_md_lst = lammps_thermal_expansion_loop(
         structure=structure,
         potential_dataframe=potential_dataframe,
-        input_template=Template(init_str).render(
-            thermo=100, temp=Tstart, timestep=0.001, seed=4928459, dist="gaussian"
-        ),
+        init_str=init_str,
+        run_str=run_str,
+        temperature_lst=temperature_lst,
         lmp=lmp,
     )
-
-    volume_md_lst = []
-    temperature_lst = np.arange(Tstart, Tstop + Tstep, Tstep).tolist()
-    for temp in temperature_lst:
-        run_str_rendered = Template(run_str).render(
-            run=100,
-            Tstart=temp - 5,
-            Tstop=temp,
-            Tdamp=0.1,
-            Pstart=0.0,
-            Pstop=0.0,
-            Pdamp=1.0,
-        )
-        for l in run_str_rendered.split("\n"):
-            lmp.interactive_lib_command(l)
-        volume_md_lst.append(lmp.interactive_volume_getter())
     return temperature_lst, volume_md_lst
 
 
@@ -224,7 +210,10 @@ def evaluate_with_lammps_library(
             **lmp_optimizer_kwargs,
         )
     elif "calc_molecular_dynamics_thermal_expansion" in tasks:
-        temperature_lst, volume_md_lst = calc_thermal_expansion_md(
+        (
+            temperature_lst,
+            volume_md_lst,
+        ) = calc_molecular_dynamics_thermal_expansion_with_lammps(
             structure=structure,
             potential_dataframe=potential_dataframe,
             lmp=lmp,
diff --git a/atomistics/calculators/lammps/helpers.py b/atomistics/calculators/lammps/helpers.py
index b67f6edb..dfa13174 100644
--- a/atomistics/calculators/lammps/helpers.py
+++ b/atomistics/calculators/lammps/helpers.py
@@ -1,19 +1,8 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
-
 from jinja2 import Template
-import pandas
 from pylammpsmpi import LammpsASELibrary
 
-from atomistics.calculators.wrapper import as_task_dict_evaluator
-from atomistics.calculators.lammps.commands import (
-    LAMMPS_THERMO_STYLE,
-    LAMMPS_THERMO,
-    LAMMPS_MINIMIZE,
-    LAMMPS_RUN,
-    LAMMPS_MINIMIZE_VOLUME,
-)
 from atomistics.calculators.lammps.potential import validate_potential_dataframe
 
 
@@ -75,6 +64,40 @@ def lammps_run(structure, potential_dataframe, input_template, lmp=None):
     return lmp
 
 
+def lammps_thermal_expansion_loop(
+    structure, potential_dataframe, init_str, run_str, temperature_lst, lmp=None
+):
+    lmp_instance = lammps_run(
+        structure=structure,
+        potential_dataframe=potential_dataframe,
+        input_template=Template(init_str).render(
+            thermo=100,
+            temp=temperature_lst[0],
+            timestep=0.001,
+            seed=4928459,
+            dist="gaussian",
+        ),
+        lmp=lmp,
+    )
+
+    volume_md_lst = []
+    for temp in temperature_lst:
+        run_str_rendered = Template(run_str).render(
+            run=100,
+            Tstart=temp - 5,
+            Tstop=temp,
+            Tdamp=0.1,
+            Pstart=0.0,
+            Pstop=0.0,
+            Pdamp=1.0,
+        )
+        for l in run_str_rendered.split("\n"):
+            lmp_instance.interactive_lib_command(l)
+        volume_md_lst.append(lmp_instance.interactive_volume_getter())
+    lammps_shutdown(lmp_instance=lmp_instance, close_instance=lmp is None)
+    return volume_md_lst
+
+
 def lammps_shutdown(lmp_instance, close_instance=True):
     lmp_instance.interactive_lib_command("clear")
     if close_instance:
diff --git a/atomistics/workflows/__init__.py b/atomistics/workflows/__init__.py
index f9104b6b..fb38794e 100644
--- a/atomistics/workflows/__init__.py
+++ b/atomistics/workflows/__init__.py
@@ -2,7 +2,7 @@
 from atomistics.workflows.evcurve.workflow import EnergyVolumeCurveWorkflow
 from atomistics.workflows.langevin.workflow import LangevinWorkflow
 from atomistics.workflows.molecular_dynamics.workflow import (
-    calc_molecular_dynamics_thermal_expansion
+    calc_molecular_dynamics_thermal_expansion,
 )
 from atomistics.workflows.structure_optimization.workflow import (
     optimize_positions,
diff --git a/atomistics/workflows/molecular_dynamics/workflow.py b/atomistics/workflows/molecular_dynamics/workflow.py
index 2bb26160..eb129d4d 100644
--- a/atomistics/workflows/molecular_dynamics/workflow.py
+++ b/atomistics/workflows/molecular_dynamics/workflow.py
@@ -1,2 +1,2 @@
 def calc_molecular_dynamics_thermal_expansion(structure):
-    return {"calc_molecular_dynamics_thermal_expansion": structure}
\ No newline at end of file
+    return {"calc_molecular_dynamics_thermal_expansion": structure}
diff --git a/tests/test_molecular_dynamics_thermal_expansion_lammps.py b/tests/test_molecular_dynamics_thermal_expansion_lammps.py
index 96030f9f..ae471486 100644
--- a/tests/test_molecular_dynamics_thermal_expansion_lammps.py
+++ b/tests/test_molecular_dynamics_thermal_expansion_lammps.py
@@ -8,7 +8,9 @@
 
 try:
     from atomistics.calculators import (
-        evaluate_with_lammps, get_potential_by_name
+        calc_molecular_dynamics_thermal_expansion_with_lammps,
+        evaluate_with_lammps,
+        get_potential_by_name,
     )
 
     skip_lammps_test = False
@@ -20,7 +22,7 @@
     skip_lammps_test, "LAMMPS is not installed, so the LAMMPS tests are skipped."
 )
 class TestMolecularDynamicsThermalExpansion(unittest.TestCase):
-    def test_calc_thermal_expansion(self):
+    def test_calc_thermal_expansion_using_evaluate(self):
         structure = bulk("Al", cubic=True)
         df_pot_selected = get_potential_by_name(
             potential_name='1999--Mishin-Y--Al--LAMMPS--ipr1',
@@ -37,6 +39,23 @@ def test_calc_thermal_expansion(self):
             }
         )
         temperature_lst = result_dict['volume_over_temperature'][0]
-        volume_lst = result_dict['volume_over_temperature'][0]
+        volume_lst = result_dict['volume_over_temperature'][1]
+        self.assertEqual(temperature_lst, [50, 100, 150, 200, 250, 300, 350, 400, 450, 500])
+        self.assertTrue(volume_lst[0] < volume_lst[-1])
+
+    def test_calc_thermal_expansion_using_calc(self):
+        structure = bulk("Al", cubic=True)
+        df_pot_selected = get_potential_by_name(
+            potential_name='1999--Mishin-Y--Al--LAMMPS--ipr1',
+            resource_path=os.path.join(os.path.dirname(__file__), "static", "lammps"),
+        )
+        temperature_lst, volume_lst = calc_molecular_dynamics_thermal_expansion_with_lammps(
+            structure=structure,
+            potential_dataframe=df_pot_selected,
+            Tstart=50,
+            Tstop=500,
+            Tstep=50,
+            lmp=None,
+        )
         self.assertEqual(temperature_lst, [50, 100, 150, 200, 250, 300, 350, 400, 450, 500])
         self.assertTrue(volume_lst[0] < volume_lst[-1])

From 242604ea33776bca9f664a876e9e19aedf4874a8 Mon Sep 17 00:00:00 2001
From: Jan Janssen <janssen@mpie.de>
Date: Tue, 28 Nov 2023 18:39:46 +0100
Subject: [PATCH 3/5] update documentation

---
 docs/source/materialproperties.md             |  90 ++++---------
 notebooks/thermal_expansion_with_lammps.ipynb | 126 +++++-------------
 ...cular_dynamics_thermal_expansion_lammps.py |   9 ++
 3 files changed, 64 insertions(+), 161 deletions(-)

diff --git a/docs/source/materialproperties.md b/docs/source/materialproperties.md
index 3ae1110e..90f43912 100644
--- a/docs/source/materialproperties.md
+++ b/docs/source/materialproperties.md
@@ -488,77 +488,35 @@ The optimal volume at the different `temperatures` is stored in the `vol_lst` in
 ### Molecular Dynamics
 Finally, the third and most commonly used method to determine the volume expansion is using a molecular dynamics 
 calculation. While the `atomistics` package already includes a `LangevinWorkflow` at this point we use the [Nose-Hoover
-thermostat implemented in LAMMPS](https://docs.lammps.org/fix_nh.html) directly via the [pylammpsmpi](https://github.com/pyiron/pylammpsmpi)
-interface. 
+thermostat implemented in LAMMPS](https://docs.lammps.org/fix_nh.html) directly via the LAMMPS calculator interface. 
 ```
-from jinja2 import Template
-from pylammpsmpi import LammpsASELibrary
-from tqdm import tqdm
+from atomistics.calculators import calc_molecular_dynamics_thermal_expansion_with_lammps
 
-def calc_thermal_expansion_md(structure, potential_dataframe, temperature_lst):
-    init_str = """\
-thermo_style custom step temp pe etotal pxx pxy pxz pyy pyz pzz vol
-thermo_modify format float %20.15g
-timestep 0.001
-thermo {{ thermotime }}
-velocity all create $(2 * {{ lowtemp }}) 4928459 dist gaussian
-"""
-
-    run_str = """\
-fix ensemble all npt temp {{ lowtemp }} {{ hightemp }} 0.1 iso 0.0 0.0 1.0
-run {{ steps }}
-"""
-
-    lmp = LammpsASELibrary()
-    potential_series = potential_dataframe.iloc[0]
-    lmp.interactive_structure_setter(
-        structure=structure,
-        units="metal",
-        dimension=3,
-        boundary=" ".join(["p" if coord else "f" for coord in structure.pbc]),
-        atom_style="atomic",
-        el_eam_lst=potential_series.Species,
-        calc_md=False,
-    )
-    for c in potential_series.Config:
-        lmp.interactive_lib_command(c)
-    init_str_rendered = Template(init_str).render(
-        thermotime=100,
-        lowtemp=10
-    )
-    for l in init_str_rendered.split("\n"):
-        lmp.interactive_lib_command(l)
-    
-    volume_md_lst = []
-    for temp in tqdm(temperature_lst):
-        run_str_rendered = Template(run_str).render(
-            steps=100,
-            lowtemp=temp-5,
-            hightemp=temp,
-        )
-        for l in run_str_rendered.split("\n"):
-            lmp.interactive_lib_command(l)
-        volume_md_lst.append(lmp.interactive_volume_getter())
-    lmp.close()
-    return volume_md_lst
-```
-The `calc_thermal_expansion_md()` function defines a loop over a vector of temperatures in 5K steps. For each step 100
-molecular dynamics steps are executed before the temperature is again increased by 5K. For ~280 steps with the Morse 
-Pair Potential this takes approximately 5 minutes on a single core. These simulations can be further accelerated by 
-adding the `cores` parameter during the initialization of the `LammpsASELibrary()`. The increase in computational cost
-is on the one hand related to the large number of force and energy calls and on the other hand to the size of the atomistic
-structure, as these simulations are typically executed with >5000 atoms rather than the 4 or 108 atoms in the other 
-approximations. 
-```
 structure_md = structure_opt.repeat(11)
-temperature_md_lst = np.linspace(15, 1400, 278)
-volume_md_lst = calc_thermal_expansion_md(
-    structure=structure_md, 
-    potential_dataframe=potential_dataframe, 
-    temperature_lst=temperature_md_lst, 
+temperature_md_lst, volume_md_lst = calc_molecular_dynamics_thermal_expansion_with_lammps(
+    structure=structure,                       # atomistic structure
+    potential_dataframe=potential_dataframe,   # interatomic potential defined as pandas.DataFrame 
+    Tstart=15,                                 # temperature to for initial velocity distribution
+    Tstop=1500,                                # final temperature
+    Tstep=5,                                   # temperature step
+    Tdamp=0.1,                                 # temperature damping of the thermostat 
+    run=100,                                   # number of MD steps for each temperature
+    thermo=100,                                # print out from the thermostat
+    timestep=0.001,                            # time step for molecular dynamics 
+    Pstart=0.0,                                # initial pressure
+    Pstop=0.0,                                 # final pressure 
+    Pdamp=1.0,                                 # barostat damping 
+    seed=4928459,                              # random seed 
+    dist="gaussian",                           # Gaussian velocity distribution 
 )
 ```
-The volume for the individual temperatures is stored in the `volume_md_lst` list. 
+The `calc_molecular_dynamics_thermal_expansion_with_lammps()` function defines a loop over a vector of temperatures in 
+5K steps. For each step 100 molecular dynamics steps are executed before the temperature is again increased by 5K. For 
+~280 steps with the Morse Pair Potential this takes approximately 5 minutes on a single core. These simulations can be 
+further accelerated by adding the `cores` parameter. The increase in computational cost is on the one hand related to 
+the large number of force and energy calls and on the other hand to the size of the atomistic structure, as these 
+simulations are typically executed with >5000 atoms rather than the 4 or 108 atoms in the other approximations. The 
+volume for the individual temperatures is stored in the `volume_md_lst` list. 
 
 ### Summary
 To visually compare the thermal expansion predicted by the three different approximations, the [matplotlib](https://matplotlib.org)
diff --git a/notebooks/thermal_expansion_with_lammps.ipynb b/notebooks/thermal_expansion_with_lammps.ipynb
index 7b826e1d..ba40b886 100644
--- a/notebooks/thermal_expansion_with_lammps.ipynb
+++ b/notebooks/thermal_expansion_with_lammps.ipynb
@@ -106,7 +106,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/janssen/mambaforge/lib/python3.10/site-packages/pylammpsmpi/wrapper/ase.py:165: UserWarning: Warning: setting upper trangular matrix might slow down the calculation\n",
+      "/Users/janssen/mambaforge/lib/python3.10/site-packages/pylammpsmpi/wrapper/ase.py:165: UserWarning: Warning: setting upper trangular matrix might slow down the calculation\n",
       "  warnings.warn(\n"
      ]
     }
@@ -217,7 +217,7 @@
        "{'energy': {0.95: -14.609207927145926,\n",
        "  0.96: -14.656740101454448,\n",
        "  0.97: -14.692359030099395,\n",
-       "  0.98: -14.716883724875528,\n",
+       "  0.98: -14.716883724875531,\n",
        "  0.99: -14.731079276327009,\n",
        "  1.0: -14.735659820057942,\n",
        "  1.01: -14.731295089579728,\n",
@@ -259,7 +259,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/janssen/mambaforge/lib/python3.10/site-packages/atomistics/shared/thermo/debye.py:9: RuntimeWarning: overflow encountered in exp\n",
+      "/Users/janssen/projects/atomistics/atomistics/shared/thermo/debye.py:9: RuntimeWarning: overflow encountered in exp\n",
       "  return xi**3 / (np.exp(xi) - 1)\n"
      ]
     }
@@ -462,8 +462,7 @@
     "### Molecular Dynamics\n",
     "Finally, the third and most commonly used method to determine the volume expansion is using a molecular dynamics \n",
     "calculation. While the `atomistics` package already includes a `LangevinWorkflow` at this point we use the [Nose-Hoover\n",
-    "thermostat implemented in LAMMPS](https://docs.lammps.org/fix_nh.html) directly via the [pylammpsmpi](https://github.com/pyiron/pylammpsmpi)\n",
-    "interface. "
+    "thermostat implemented in LAMMPS](https://docs.lammps.org/fix_nh.html) directly via the LAMMPS calculator interface. "
    ]
   },
   {
@@ -473,102 +472,39 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from jinja2 import Template\n",
-    "from pylammpsmpi import LammpsASELibrary\n",
-    "from tqdm import tqdm\n",
+    "from atomistics.calculators import calc_molecular_dynamics_thermal_expansion_with_lammps\n",
     "\n",
-    "def calc_thermal_expansion_md(structure, potential_dataframe, temperature_lst):\n",
-    "    init_str = \"\"\"\\\n",
-    "thermo_style custom step temp pe etotal pxx pxy pxz pyy pyz pzz vol\n",
-    "thermo_modify format float %20.15g\n",
-    "timestep 0.001\n",
-    "thermo {{ thermotime }}\n",
-    "velocity all create $(2 * {{ lowtemp }}) 4928459 dist gaussian\n",
-    "\"\"\"\n",
-    "\n",
-    "    run_str = \"\"\"\\\n",
-    "fix ensemble all npt temp {{ lowtemp }} {{ hightemp }} 0.1 iso 0.0 0.0 1.0\n",
-    "run {{ steps }}\n",
-    "\"\"\"\n",
-    "\n",
-    "    lmp = LammpsASELibrary()\n",
-    "    potential_series = potential_dataframe.iloc[0]\n",
-    "    lmp.interactive_structure_setter(\n",
-    "        structure=structure,\n",
-    "        units=\"metal\",\n",
-    "        dimension=3,\n",
-    "        boundary=\" \".join([\"p\" if coord else \"f\" for coord in structure.pbc]),\n",
-    "        atom_style=\"atomic\",\n",
-    "        el_eam_lst=potential_series.Species,\n",
-    "        calc_md=False,\n",
-    "    )\n",
-    "    for c in potential_series.Config:\n",
-    "        lmp.interactive_lib_command(c)\n",
-    "    init_str_rendered = Template(init_str).render(\n",
-    "        thermotime=100,\n",
-    "        lowtemp=10\n",
-    "    )\n",
-    "    for l in init_str_rendered.split(\"\\n\"):\n",
-    "        lmp.interactive_lib_command(l)\n",
-    "    \n",
-    "    volume_md_lst = []\n",
-    "    for temp in tqdm(temperature_lst):\n",
-    "        run_str_rendered = Template(run_str).render(\n",
-    "            steps=100,\n",
-    "            lowtemp=temp-5,\n",
-    "            hightemp=temp,\n",
-    "        )\n",
-    "        for l in run_str_rendered.split(\"\\n\"):\n",
-    "            lmp.interactive_lib_command(l)\n",
-    "        volume_md_lst.append(lmp.interactive_volume_getter())\n",
-    "    lmp.close()\n",
-    "    return volume_md_lst"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d2efeb52-ee54-4eb0-878a-184f353941bf",
-   "metadata": {},
-   "source": [
-    "The `calc_thermal_expansion_md()` function defines a loop over a vector of temperatures in 5K steps. For each step 100\n",
-    "molecular dynamics steps are executed before the temperature is again increased by 5K. For ~280 steps with the Morse \n",
-    "Pair Potential this takes approximately 5 minutes on a single core. These simulations can be further accelerated by \n",
-    "adding the `cores` parameter during the initialization of the `LammpsASELibrary()`. The increase in computational cost\n",
-    "is on the one hand related to the large number of force and energy calls and on the other hand to the size of the atomistic\n",
-    "structure, as these simulations are typically executed with >5000 atoms rather than the 4 or 108 atoms in the other \n",
-    "approximations. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "9825f717-aef3-4e76-bbdb-cb4d3c00ef3a",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|█████████████████████████████████████████| 278/278 [04:37<00:00,  1.00it/s]\n"
-     ]
-    }
-   ],
-   "source": [
     "structure_md = structure_opt.repeat(11)\n",
-    "temperature_md_lst = np.linspace(15, 1400, 278)\n",
-    "volume_md_lst = calc_thermal_expansion_md(\n",
-    "    structure=structure_md, \n",
-    "    potential_dataframe=potential_dataframe, \n",
-    "    temperature_lst=temperature_md_lst, \n",
+    "temperature_md_lst, volume_md_lst = calc_molecular_dynamics_thermal_expansion_with_lammps(\n",
+    "    structure=structure_md,                    # atomistic structure\n",
+    "    potential_dataframe=potential_dataframe,   # interatomic potential defined as pandas.DataFrame \n",
+    "    Tstart=15,                                 # temperature to for initial velocity distribution\n",
+    "    Tstop=1500,                                # final temperature\n",
+    "    Tstep=5,                                   # temperature step\n",
+    "    Tdamp=0.1,                                 # temperature damping of the thermostat \n",
+    "    run=100,                                   # number of MD steps for each temperature\n",
+    "    thermo=100,                                # print out from the thermostat\n",
+    "    timestep=0.001,                            # time step for molecular dynamics \n",
+    "    Pstart=0.0,                                # initial pressure\n",
+    "    Pstop=0.0,                                 # final pressure \n",
+    "    Pdamp=1.0,                                 # barostat damping \n",
+    "    seed=4928459,                              # random seed \n",
+    "    dist=\"gaussian\",                           # Gaussian velocity distribution \n",
     ")"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "1d13a43f-63d5-456d-abab-173ba744e467",
+   "id": "d2efeb52-ee54-4eb0-878a-184f353941bf",
    "metadata": {},
    "source": [
-    "The volume for the individual temperatures is stored in the `volume_md_lst` list. "
+    "The `calc_molecular_dynamics_thermal_expansion_with_lammps()` function defines a loop over a vector of temperatures in \n",
+    "5K steps. For each step 100 molecular dynamics steps are executed before the temperature is again increased by 5K. For \n",
+    "~280 steps with the Morse Pair Potential this takes approximately 5 minutes on a single core. These simulations can be \n",
+    "further accelerated by adding the `cores` parameter. The increase in computational cost is on the one hand related to \n",
+    "the large number of force and energy calls and on the other hand to the size of the atomistic structure, as these \n",
+    "simulations are typically executed with >5000 atoms rather than the 4 or 108 atoms in the other approximations. The \n",
+    "volume for the individual temperatures is stored in the `volume_md_lst` list. "
    ]
   },
   {
@@ -583,7 +519,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 11,
    "id": "da8f641d-c5e6-4c10-8aeb-c891109e2e6d",
    "metadata": {},
    "outputs": [
@@ -593,13 +529,13 @@
        "Text(0, 0.5, 'Temperature')"
       ]
      },
-     "execution_count": 12,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
diff --git a/tests/test_molecular_dynamics_thermal_expansion_lammps.py b/tests/test_molecular_dynamics_thermal_expansion_lammps.py
index ae471486..25536dfc 100644
--- a/tests/test_molecular_dynamics_thermal_expansion_lammps.py
+++ b/tests/test_molecular_dynamics_thermal_expansion_lammps.py
@@ -55,6 +55,15 @@ def test_calc_thermal_expansion_using_calc(self):
             Tstart=50,
             Tstop=500,
             Tstep=50,
+            Tdamp=0.1,
+            run=100,
+            thermo=100,
+            timestep=0.001,
+            Pstart=0.0,
+            Pstop=0.0,
+            Pdamp=1.0,
+            seed=4928459,
+            dist="gaussian",
             lmp=None,
         )
         self.assertEqual(temperature_lst, [50, 100, 150, 200, 250, 300, 350, 400, 450, 500])

From 034f754d5065ea88100dc045995d7cb9fc7e7116 Mon Sep 17 00:00:00 2001
From: Jan Janssen <janssen@mpie.de>
Date: Tue, 28 Nov 2023 18:40:26 +0100
Subject: [PATCH 4/5] add support for keyword arguments

---
 atomistics/calculators/lammps/calculator.py | 40 ++++++++++++++++++--
 atomistics/calculators/lammps/helpers.py    | 42 +++++++++++++++------
 2 files changed, 66 insertions(+), 16 deletions(-)

diff --git a/atomistics/calculators/lammps/calculator.py b/atomistics/calculators/lammps/calculator.py
index 481a5f18..dc968870 100644
--- a/atomistics/calculators/lammps/calculator.py
+++ b/atomistics/calculators/lammps/calculator.py
@@ -31,7 +31,7 @@
     from atomistics.calculators.interface import TaskName
 
 
-def calc_energy_with_lammps(structure: Atoms, potential_dataframe: DataFrame, lmp=None):
+def calc_energy_with_lammps(structure: Atoms, potential_dataframe: DataFrame, lmp=None, **kwargs):
     template_str = LAMMPS_THERMO_STYLE + "\n" + LAMMPS_THERMO + "\n" + LAMMPS_RUN
     lmp_instance = lammps_run(
         structure=structure,
@@ -42,13 +42,14 @@ def calc_energy_with_lammps(structure: Atoms, potential_dataframe: DataFrame, lm
             run=0,
         ),
         lmp=lmp,
+        **kwargs,
     )
     energy_pot = lmp_instance.interactive_energy_pot_getter()
     lammps_shutdown(lmp_instance=lmp_instance, close_instance=lmp is None)
     return energy_pot
 
 
-def calc_forces_with_lammps(structure: Atoms, potential_dataframe: DataFrame, lmp=None):
+def calc_forces_with_lammps(structure: Atoms, potential_dataframe: DataFrame, lmp=None, **kwargs):
     template_str = LAMMPS_THERMO_STYLE + "\n" + LAMMPS_THERMO + "\n" + LAMMPS_RUN
     lmp_instance = lammps_run(
         structure=structure,
@@ -59,6 +60,7 @@ def calc_forces_with_lammps(structure: Atoms, potential_dataframe: DataFrame, lm
             run=0,
         ),
         lmp=lmp,
+        **kwargs,
     )
     forces = lmp_instance.interactive_forces_getter()
     lammps_shutdown(lmp_instance=lmp_instance, close_instance=lmp is None)
@@ -66,7 +68,7 @@ def calc_forces_with_lammps(structure: Atoms, potential_dataframe: DataFrame, lm
 
 
 def calc_energy_and_forces_with_lammps(
-    structure, potential_dataframe: DataFrame, lmp=None
+    structure, potential_dataframe: DataFrame, lmp=None, **kwargs
 ):
     template_str = LAMMPS_THERMO_STYLE + "\n" + LAMMPS_THERMO + "\n" + LAMMPS_RUN
     lmp_instance = lammps_run(
@@ -78,6 +80,7 @@ def calc_energy_and_forces_with_lammps(
             run=0,
         ),
         lmp=lmp,
+        **kwargs,
     )
     energy_pot = lmp_instance.interactive_energy_pot_getter()
     forces = lmp_instance.interactive_forces_getter()
@@ -95,6 +98,7 @@ def optimize_positions_and_volume_with_lammps(
     maxeval=10000000,
     thermo=10,
     lmp=None,
+    **kwargs
 ):
     template_str = (
         LAMMPS_MINIMIZE_VOLUME
@@ -118,6 +122,7 @@ def optimize_positions_and_volume_with_lammps(
             thermo=thermo,
         ),
         lmp=lmp,
+        **kwargs,
     )
     structure_copy = structure.copy()
     structure_copy.set_cell(lmp_instance.interactive_cells_getter(), scale_atoms=True)
@@ -136,6 +141,7 @@ def optimize_positions_with_lammps(
     maxeval=10000000,
     thermo=10,
     lmp=None,
+    **kwargs
 ):
     template_str = LAMMPS_THERMO_STYLE + "\n" + LAMMPS_THERMO + "\n" + LAMMPS_MINIMIZE
     lmp_instance = lammps_run(
@@ -151,6 +157,7 @@ def optimize_positions_with_lammps(
             thermo=thermo,
         ),
         lmp=lmp,
+        **kwargs,
     )
     structure_copy = structure.copy()
     structure_copy.positions = lmp_instance.interactive_positions_getter()
@@ -159,7 +166,22 @@ def optimize_positions_with_lammps(
 
 
 def calc_molecular_dynamics_thermal_expansion_with_lammps(
-    structure, potential_dataframe, Tstart=15, Tstop=1500, Tstep=5, lmp=None
+    structure,
+    potential_dataframe,
+    Tstart=15,
+    Tstop=1500,
+    Tstep=5,
+    Tdamp=0.1,
+    run=100,
+    thermo=100,
+    timestep=0.001,
+    Pstart=0.0,
+    Pstop=0.0,
+    Pdamp=1.0,
+    seed=4928459,
+    dist="gaussian",
+    lmp=None,
+    **kwargs
 ):
     init_str = (
         LAMMPS_THERMO_STYLE
@@ -179,7 +201,17 @@ def calc_molecular_dynamics_thermal_expansion_with_lammps(
         init_str=init_str,
         run_str=run_str,
         temperature_lst=temperature_lst,
+        run=run,
+        thermo=thermo,
+        timestep=timestep,
+        Tdamp=Tdamp,
+        Pstart=Pstart,
+        Pstop=Pstop,
+        Pdamp=Pdamp,
+        seed=seed,
+        dist=dist,
         lmp=lmp,
+        **kwargs,
     )
     return temperature_lst, volume_md_lst
 
diff --git a/atomistics/calculators/lammps/helpers.py b/atomistics/calculators/lammps/helpers.py
index dfa13174..e13c67eb 100644
--- a/atomistics/calculators/lammps/helpers.py
+++ b/atomistics/calculators/lammps/helpers.py
@@ -36,12 +36,14 @@ def template_render_run(
     )
 
 
-def lammps_run(structure, potential_dataframe, input_template, lmp=None):
+def lammps_run(structure, potential_dataframe, input_template, lmp=None, **kwargs):
     potential_dataframe = validate_potential_dataframe(
         potential_dataframe=potential_dataframe
     )
     if lmp is None:
-        lmp = LammpsASELibrary()
+        lmp = LammpsASELibrary(
+            **kwargs
+        )
 
     # write structure to LAMMPS
     lmp.interactive_structure_setter(
@@ -65,31 +67,47 @@ def lammps_run(structure, potential_dataframe, input_template, lmp=None):
 
 
 def lammps_thermal_expansion_loop(
-    structure, potential_dataframe, init_str, run_str, temperature_lst, lmp=None
+    structure,
+    potential_dataframe,
+    init_str,
+    run_str,
+    temperature_lst,
+    run=100,
+    thermo=100,
+    timestep=0.001,
+    Tdamp=0.1,
+    Pstart=0.0,
+    Pstop=0.0,
+    Pdamp=1.0,
+    seed=4928459,
+    dist="gaussian",
+    lmp=None,
+    **kwargs,
 ):
     lmp_instance = lammps_run(
         structure=structure,
         potential_dataframe=potential_dataframe,
         input_template=Template(init_str).render(
-            thermo=100,
+            thermo=thermo,
             temp=temperature_lst[0],
-            timestep=0.001,
-            seed=4928459,
-            dist="gaussian",
+            timestep=timestep,
+            seed=seed,
+            dist=dist,
         ),
         lmp=lmp,
+        **kwargs,
     )
 
     volume_md_lst = []
     for temp in temperature_lst:
         run_str_rendered = Template(run_str).render(
-            run=100,
+            run=run,
             Tstart=temp - 5,
             Tstop=temp,
-            Tdamp=0.1,
-            Pstart=0.0,
-            Pstop=0.0,
-            Pdamp=1.0,
+            Tdamp=Tdamp,
+            Pstart=Pstart,
+            Pstop=Pstop,
+            Pdamp=Pdamp,
         )
         for l in run_str_rendered.split("\n"):
             lmp_instance.interactive_lib_command(l)

From d6a0644276ec497926fc0767fad0617fdee446f2 Mon Sep 17 00:00:00 2001
From: Jan Janssen <janssen@mpie.de>
Date: Tue, 28 Nov 2023 18:41:13 +0100
Subject: [PATCH 5/5] black formatting

---
 atomistics/calculators/lammps/calculator.py | 14 +++++++++-----
 atomistics/calculators/lammps/helpers.py    |  4 +---
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/atomistics/calculators/lammps/calculator.py b/atomistics/calculators/lammps/calculator.py
index dc968870..ae1de770 100644
--- a/atomistics/calculators/lammps/calculator.py
+++ b/atomistics/calculators/lammps/calculator.py
@@ -31,7 +31,9 @@
     from atomistics.calculators.interface import TaskName
 
 
-def calc_energy_with_lammps(structure: Atoms, potential_dataframe: DataFrame, lmp=None, **kwargs):
+def calc_energy_with_lammps(
+    structure: Atoms, potential_dataframe: DataFrame, lmp=None, **kwargs
+):
     template_str = LAMMPS_THERMO_STYLE + "\n" + LAMMPS_THERMO + "\n" + LAMMPS_RUN
     lmp_instance = lammps_run(
         structure=structure,
@@ -49,7 +51,9 @@ def calc_energy_with_lammps(structure: Atoms, potential_dataframe: DataFrame, lm
     return energy_pot
 
 
-def calc_forces_with_lammps(structure: Atoms, potential_dataframe: DataFrame, lmp=None, **kwargs):
+def calc_forces_with_lammps(
+    structure: Atoms, potential_dataframe: DataFrame, lmp=None, **kwargs
+):
     template_str = LAMMPS_THERMO_STYLE + "\n" + LAMMPS_THERMO + "\n" + LAMMPS_RUN
     lmp_instance = lammps_run(
         structure=structure,
@@ -98,7 +102,7 @@ def optimize_positions_and_volume_with_lammps(
     maxeval=10000000,
     thermo=10,
     lmp=None,
-    **kwargs
+    **kwargs,
 ):
     template_str = (
         LAMMPS_MINIMIZE_VOLUME
@@ -141,7 +145,7 @@ def optimize_positions_with_lammps(
     maxeval=10000000,
     thermo=10,
     lmp=None,
-    **kwargs
+    **kwargs,
 ):
     template_str = LAMMPS_THERMO_STYLE + "\n" + LAMMPS_THERMO + "\n" + LAMMPS_MINIMIZE
     lmp_instance = lammps_run(
@@ -181,7 +185,7 @@ def calc_molecular_dynamics_thermal_expansion_with_lammps(
     seed=4928459,
     dist="gaussian",
     lmp=None,
-    **kwargs
+    **kwargs,
 ):
     init_str = (
         LAMMPS_THERMO_STYLE
diff --git a/atomistics/calculators/lammps/helpers.py b/atomistics/calculators/lammps/helpers.py
index e13c67eb..036c3fd1 100644
--- a/atomistics/calculators/lammps/helpers.py
+++ b/atomistics/calculators/lammps/helpers.py
@@ -41,9 +41,7 @@ def lammps_run(structure, potential_dataframe, input_template, lmp=None, **kwarg
         potential_dataframe=potential_dataframe
     )
     if lmp is None:
-        lmp = LammpsASELibrary(
-            **kwargs
-        )
+        lmp = LammpsASELibrary(**kwargs)
 
     # write structure to LAMMPS
     lmp.interactive_structure_setter(