store relative path in render to use in save

Author: Joost Delsman

imod/wq/ani.py

@@ -6,58 +6,65 @@
 import imod
 from imod.wq.pkgbase import Package
 
+
 class HorizontalAnisotropyFile(Package):
     """
     Horizontal Anisotropy package.
 
     Parameters
     ----------
     anifile: str
-        is the file location of the imod-wq ani-file. This file contains the 
+        is the file location of the imod-wq ani-file. This file contains the
         anisotropy factor and angle of each layer, either as a constant or a
-        reference to the file location of an '.arr' file. No checks are 
-        implemented for this file, user is responsible for consistency with 
+        reference to the file location of an '.arr' file. No checks are
+        implemented for this file, user is responsible for consistency with
         model.
     """
 
     _pkg_id = "ani"
 
-    _template = (
-        "[ani]\n"
-        "    anifile = {anifile}\n"
-    )
+    _template = "[ani]\n" "    anifile = {anifile}\n\n"
 
     def __init__(
         self,
         anifile,
     ):
         super().__init__()
         self["anifile"] = anifile
-    
-    def _render(self, directory, *args, **kwargs):
-        path_ani = pathlib.Path(str(self['anifile'].values))
-        d = {"anifile": f"ani/{path_ani.name}"}
+
+    def _render(self, modelname, directory, nlayer):
+        # write ani file
+        # in render function, as here we know where the model is run from
+        # and how many layers: store this info for later use in save
+        self.anifile = f"{modelname}.ani"
+        self.rendir = directory
+        self.nlayer = nlayer
+
+        d = {"anifile": f"{directory.as_posix()}/{modelname}.ani"}
 
         return self._template.format(**d)
-            
+
     def save(self, directory):
-        """Overload save function. 
-        Saves anifile to location, along with referenced .arr files"""
-        directory.mkdir(exist_ok=True)
-        
-        path_ani = pathlib.Path(str(self['anifile'].values))
-        
+        """Overload save function.
+        Saves anifile to location, along with referenced .arr files
+        assumes _render() to have run previously"""
+        directory.mkdir(exist_ok=True)  # otherwise handled by idf.save
+
+        path_ani = pathlib.Path(str(self["anifile"].values))
+
         # regex adapted from stackoverflow: https://stackoverflow.com/questions/54990405/a-general-regex-to-extract-file-paths-not-urls
-        rgx = r'((?:[a-zA-Z]:|(?<![:/\\])[\\\/](?!CLOSE)(?!close )|\~[\\\/]|(?:\.{1,2}[\\\/])+)[\w+\\\s_\-\(\)\/]*(?:\.\w+)*)'
-        with open(path_ani, "r") as f, open(directory / path_ani.name, "w") as f2:
+        rgx = r"((?:[a-zA-Z]:|(?<![:/\\])[\\\/](?!CLOSE)(?!close )|\~[\\\/]|(?:\.{1,2}[\\\/])+)[\w+\\\s_\-\(\)\/]*(?:\.\w+)*)"
+        with open(path_ani, "r") as f, open(directory / self.anifile, "w") as f2:
             for line in f:
                 p = re.search(rgx, line)
                 if p:
-                    # path to file detected, 
+                    # path to file detected,
                     # replace to relative and
                     # copy to directory
                     path = pathlib.Path(p[0])
-                    f2.write(line.replace(p[0], f"{directory.stem}/{path.name}"))
+                    f2.write(
+                        line.replace(p[0], f"{self.rendir.as_posix()}/{path.name}")
+                    )
                     if not path.is_absolute():
                         path = path_ani.parent / path
                     shutil.copyfile(path, directory / path.name)
@@ -72,47 +79,50 @@ class HorizontalAnisotropy(Package):
     """
     Horizontal Anisotropy package.
     Anisotropy is a phenomenon for which the permeability k is not equal along the x- and y Cartesian axis.
-    
+
     Parameters
     ----------
     factor : float or xr.DataArray of floats
-        The anisotropic factor perpendicular to the main principal axis (axis of highest permeability). 
+        The anisotropic factor perpendicular to the main principal axis (axis of highest permeability).
         Factor between 0.0 (full anisotropic) and 1.0 (full isotropic).
     angle : float or xr.DataArray of floats
         The angle along the main principal axis (highest permeability) measured in degrees from north (0),
         east (90), south (180) and west (270).
-    fn_ani : filename for created anifile, optional
-        Default: ani.ani
     """
 
     _pkg_id = "ani"
 
-    _template = (
-        "[ani]\n"
-        "    anifile = {anifile}\n"
-    )
+    _template = "[ani]\n" "    anifile = {anifile}\n\n"
 
     def __init__(
         self,
         factor,
         angle,
-        fn_ani="ani.ani"
     ):
         super().__init__()
         self["factor"] = factor
-        self["factor"] = self["factor"].fillna(1.)
+        self["factor"] = self["factor"].fillna(1.0)
         self["angle"] = angle
-        self["angle"] = self["angle"].fillna(0.)
-        self["fn_ani"] = fn_ani
-    
-    def _render(self, directory, *args, **kwargs):
-        d = {"anifile": f"ani/{str(self['fn_ani'].values)}"}
+        self["angle"] = self["angle"].fillna(0.0)
+
+    def _render(self, modelname, directory, nlayer):
+        # write ani file
+        # in render function, as here we know where the model is run from
+        # and how many layers: store this info for later use in save
+        self.anifile = f"{modelname}.ani"
+        self.rendir = directory
+        self.nlayer = nlayer
+
+        d = {"anifile": f"{directory.as_posix()}/{modelname}.ani"}
 
         return self._template.format(**d)
-            
+
     def save(self, directory):
-        """Overload save function. 
-        Saves anifile to location, along with referenced .arr files"""
+        """Overload save function.
+        Saves anifile to location, along with created .arr files
+        assumes _render() to have run previously"""
+        directory.mkdir(exist_ok=True)  # otherwise handled by idf.save
+
         def _write(path, a, nodata=1.0e20, dtype=np.float32):
             if not np.all(a == a[0][0]):
                 return np.savetxt(path, a, fmt="%.5f", delimiter=" ")
@@ -124,22 +134,39 @@ def _write(path, a, nodata=1.0e20, dtype=np.float32):
             if "y" in da.coords and "x" in da.coords:
                 path = pathlib.Path(directory).joinpath(f"{name}.arr")
                 if name == "factor":
-                    nodata = 1.
+                    nodata = 1.0
                 elif name == "angle":
-                    nodata = 0.
+                    nodata = 0.0
                 else:
                     nodata = 1.0e20
-                imod.array_io.writing._save(path, da, nodata=nodata, pattern=None, dtype=np.float32, write=_write)
-
-        # write ani file
-        with open(directory / f"{str(self['fn_ani'].values)}", "w") as f:
-            for l in self.dataset.layer.values:
-                for prm in ["factor","angle"]:
-                    a = self.dataset[prm].sel(layer=l).values
-                    if not np.all(a == a[0][0]):
-                        f.write(f"open/close {directory.as_posix()}/{prm}_l{float(l):.0f}.arr 1.0D0 (FREE) -1 {prm}_l{float(l):.0f}\n")
+                imod.array_io.writing._save(
+                    path,
+                    da,
+                    nodata=nodata,
+                    pattern=None,
+                    dtype=np.float32,
+                    write=_write,
+                )
+
+        # save anifile with data stored during _render
+        with open(directory / self.anifile, "w") as f:
+            for l in range(1, self.nlayer + 1):
+                for prm in ["factor", "angle"]:
+                    da = self.dataset[prm]
+                    if "layer" in da.coords and "y" in da.coords and "x" in da.coords:
+                        a = da.sel(layer=l).values
+                        if not np.all(a == a[0][0]):
+                            f.write(
+                                f"open/close {self.rendir.as_posix()}/{prm}_l{float(l):.0f}.arr 1.0D0 (FREE) -1 {prm}_l{float(l):.0f}\n"
+                            )
+                        else:
+                            f.write(
+                                f"constant {float(a[0][0]):.5f} {prm}_l{float(l):.0f}\n"
+                            )
                     else:
-                        f.write(f"constant {float(a[0][0]):.5f} {prm}_l{float(l):.0f}\n")
+                        f.write(
+                            f"constant {float(self.dataset[prm].values):.5f} {prm}_l{float(l):.0f}\n"
+                        )
 
     def _pkgcheck(self, ibound=None):
         pass

imod/wq/hfb.py

@@ -2,47 +2,46 @@
 import shutil
 from imod.wq.pkgbase import Package
 
+
 class HorizontalFlowBarrier(Package):
     """
     Horizontal Flow Barrier package.
 
     Parameters
     ----------
     hfbfile: str
-        is the file location of the imod-wq hfb-file. This file contains cell- 
+        is the file location of the imod-wq hfb-file. This file contains cell-
         to-cell resistance values. The hfb file can be constructed from generate
-        files using imod-batch. No checks are implemented for this file, user is 
+        files using imod-batch. No checks are implemented for this file, user is
         responsible for consistency with model.
     """
 
     _pkg_id = "hfb"
 
-    _template = (
-        "[hfb]\n"
-        "    hfbfile = {hfbfile}\n"
-    )
+    _template = "[hfb]\n" "    hfbfile = {hfbfile}\n\n"
 
     def __init__(
         self,
         hfbfile,
     ):
         super().__init__()
         self["hfbfile"] = hfbfile
-    
-    def _render(self, directory, *args, **kwargs):
-        path_hfb = pathlib.Path(str(self["hfbfile"].values))
-        d = {"hfbfile": f"hfb/{path_hfb.name}"}
+
+    def _render(self, modelname, directory, *args, **kwargs):
+        self.hfbfile = f"{modelname}.hfb"
+        d = {"hfbfile": f"{directory.as_posix()}/{modelname}.hfb"}
 
         return self._template.format(**d)
-            
+
     def save(self, directory):
-        """Overloads save function. 
-        Saves hfbfile to directory"""
-        directory.mkdir(exist_ok=True)
-        
+        """Overloads save function.
+        Saves hfbfile to directory
+        assumes _render() to have run previously"""
+        directory.mkdir(exist_ok=True)  # otherwise handled by idf.save
+
         path_hfb = pathlib.Path(str(self["hfbfile"].values))
-        
-        shutil.copyfile(path_hfb, directory / path_hfb.name)
+
+        shutil.copyfile(path_hfb, directory / self.hfbfile)
 
     def _pkgcheck(self, ibound=None):
         pass

imod/wq/model.py

@@ -605,6 +605,16 @@ def _bas_btn_rch_evt_mal_tvc_sinkssources(self):
 
         return n_extra
 
+    def _render_anihfb(self, modelname, directory, nlayer):
+        out = ""
+        for key in ("ani", "hfb"):
+            pkgkey = self._get_pkgkey(key)
+            if pkgkey is not None:
+                out += self[pkgkey]._render(
+                    modelname=modelname, directory=directory / pkgkey, nlayer=nlayer
+                )
+        return out
+
     def render(self, directory, result_dir, writehelp):
         """
         Render the runfile as a string, package by package.
@@ -636,6 +646,13 @@ def render(self, directory, result_dir, writehelp):
                 )
             )
 
+        # ani and hfb packages
+        content.append(
+            self._render_anihfb(
+                modelname=self.modelname, directory=directory, nlayer=nlayer
+            )
+        )
+
         # multi-system package group: chd, drn, ghb, riv, wel
         modflowcontent, ssm_content, n_sinkssources = self._render_groups(
             directory=directory, globaltimes=globaltimes
@@ -666,7 +683,7 @@ def render(self, directory, result_dir, writehelp):
                 directory=directory, globaltimes=globaltimes, nlayer=nlayer
             )
         )
-        for key in ("vdf", "adv", "dsp", "ani", "hfb"):
+        for key in ("vdf", "adv", "dsp"):
             content.append(
                 self._render_pkg(
                     key=key, directory=directory, globaltimes=globaltimes, nlayer=nlayer