Merge pull request #301 from pyiron/refactor_loading

[minor] Refactor `join_path`

pyiron_continuum/damask/damaskjob.py

@@ -14,9 +14,9 @@
 ) as damask_alarm:
     from damask import Result
 from pyiron_continuum.damask.factory import Create as DAMASKCreator, GridFactory
-import os
 import numpy as np
 import matplotlib.pyplot as plt
+from pathlib import Path
 
 __author__ = "Muhammad Hassani"
 __copyright__ = (
@@ -50,6 +50,12 @@ def __init__(self, project, job_name):
         self.input.material = None
         self.input.loading = None
 
+    def _join_path(self, path, return_str=True):
+        file_path = Path(self.working_directory) / path
+        if return_str:
+            return str(file_path)
+        return file_path
+
     def set_elasticity(self, **kwargs):
         """
         Example:
@@ -225,6 +231,21 @@ def loading(self, value):
         )
         self.input.loading = value
 
+    @staticmethod
+    def get_dot_F(reduction_speed):
+        return [["x", 0, 0], [0, 0, 0], [0, 0, -1.0 * reduction_speed]]
+
+    @staticmethod
+    def get_loadstep(dot_F, reduction_time, reduction_outputs, P=None):
+        if P is None:
+            P = [[0, "x", "x"], ["x", "x", "x"], ["x", "x", "x"]]
+        return {
+            "boundary_conditions": {"mechanical": {"P": P, "dot_F": dot_F}},
+            "discretization": {"t": reduction_time, "N": reduction_outputs},
+            "f_out": 5,
+            "f_restart": 5,
+        }
+
     def set_loading(self, solver, load_steps):
         """
         Creates the required damask loading.
@@ -243,18 +264,15 @@ def set_loading(self, solver, load_steps):
 
     def _write_material(self):
         if self.input.material is not None:
-            file_path = os.path.join(self.working_directory, "material.yaml")
-            self.input.material.save(fname=file_path)
+            self.input.material.save(self._join_path("material.yaml"))
 
     def _write_loading(self):
         if self.input.loading is not None:
-            file_path = os.path.join(self.working_directory, "loading.yaml")
-            self.input.loading.save(file_path)
+            self.input.loading.save(self._join_path("loading.yaml"))
 
     def _write_geometry(self):
         if self.input.grid is not None:
-            file_path = os.path.join(self.working_directory, "damask")
-            self.input.grid.save(file_path)
+            self.input.grid.save(self._join_path("damask"))
 
     def write_input(self):
         self._write_loading()
@@ -278,12 +296,11 @@ def _load_results(self, file_name="damask_loading_material.hdf5", run_all=True):
         Args:
             file_name(str): path to the hdf file
         """
-        damask_hdf = os.path.join(self.working_directory, file_name)
 
         def _average(d):
             return np.average(list(d.values()), axis=1)
 
-        results = Result(damask_hdf)
+        results = Result(self._join_path(file_name))
         if not run_all:
             return results
         results.add_stress_Cauchy()

pyiron_continuum/damask/rolling.py

@@ -2,7 +2,6 @@
 import matplotlib.pyplot as plt
 
 import os
-from pathlib import Path
 from pyiron_base import ImportAlarm
 
 with ImportAlarm(
@@ -31,30 +30,6 @@ def __init__(self, project, job_name):
         self.output.results_file = []
         self.output.job_names = []
 
-    def _join_path(self, path, return_str=True):
-        file_path = Path(self.working_directory) / path
-        if return_str:
-            return str(file_path)
-        return file_path
-
-    def loading_discretization(self, rolltimes, filename):
-        time = (
-            rolltimes
-            * self._height_reduction
-            / (self._rolling_speed * self._number_passes)
-        )
-
-        self.input.loading = YAML(
-            solver={"mechanical": "spectral_basic"}, loadstep=[]
-        )
-        self.input.loading["loadstep"].append(
-            self.get_loadstep(
-                self.get_dot_F(self._rollling_speed), time, self._increments * rolltimes
-            )
-        )
-        self.input.loading.save(self._join_path(filename + ".yaml"))
-        print(self.input.loading)
-
     @property
     def reduction_time(self):
         return self.input.reduction_height / self.input.reduction_speed
@@ -76,15 +51,14 @@ def set_rolling(
             self.input.regrid = regrid
 
     def write_input(self):
-        super().write_input()
         self.input.loading["loadstep"].append(
             self.get_loadstep(
                 self.get_dot_F(self.input.reduction_speed),
                 self.reduction_time,
                 self.input.reduction_outputs,
             )
         )
-        self.input.loading.save(self._join_path("loading.yaml"))
+        super().write_input()
         if self.input.regrid and len(self.input.job_names) > 0:
             self.regridding(self.input.regrid_scale)
 
@@ -94,21 +68,6 @@ def geom_name(self):
             return self.regrid_geom_name
         return "damask"
 
-    @staticmethod
-    def get_dot_F(reduction_speed):
-        return [["x", 0, 0], [0, 0, 0], [0, 0, -1.0 * reduction_speed]]
-
-    @staticmethod
-    def get_loadstep(dot_F, reduction_time, reduction_outputs, P=None):
-        if P is None:
-            P = [[0, "x", "x"], ["x", "x", "x"], ["x", "x", "x"]]
-        return {
-            "boundary_conditions": {"mechanical": {"P": P, "dot_F": dot_F}},
-            "discretization": {"t": reduction_time, "N": reduction_outputs},
-            "f_out": 5,
-            "f_restart": 5,
-        }
-
     def collect_output(self):
         self.output.job_names.append(self.job_name)
         super().collect_output()