fix: rename properties_cell to cell_properties and properties_vertex to properties for the structured grid

Author: lachlangrose

LoopStructural/datatypes/_bounding_box.py

@@ -416,7 +416,7 @@ def structured_grid(
             origin=self.global_origin,
             step_vector=self.step_vector,
             nsteps=self.nsteps,
-            properties_cell=cell_data,
-            properties_vertex=vertex_data,
+            cell_properties=cell_data,
+            properties=vertex_data,
             name=name,
         )

LoopStructural/datatypes/_structured_grid.py

@@ -8,8 +8,8 @@ class StructuredGrid:
     origin: np.ndarray
     step_vector: np.ndarray
     nsteps: np.ndarray
-    properties_cell: Dict[str, np.ndarray]
-    properties_vertex: Dict[str, np.ndarray]
+    cell_properties: Dict[str, np.ndarray]
+    properties: Dict[str, np.ndarray]
     name: str
 
     def to_dict(self):
@@ -18,8 +18,8 @@ def to_dict(self):
             "maximum": self.maximum,
             "step_vector": self.step_vector,
             "nsteps": self.nsteps,
-            "properties_cell": self.properties_cell,
-            "properties_vertex": self.properties_vertex,
+            "cell_properties": self.cell_properties,
+            "properties": self.properties,
             "name": self.name,
         }
 
@@ -40,9 +40,9 @@ def vtk(self):
             y,
             z,
         )
-        for name, data in self.properties_vertex.items():
+        for name, data in self.properties.items():
             grid[name] = data.flatten(order="F")
-        for name, data in self.properties_cell.items():
+        for name, data in self.cell_properties.items():
             grid.cell_data[name] = data.flatten(order="F")
         return grid
 
@@ -54,10 +54,10 @@ def merge(self, other):
         if not np.all(np.isclose(self.nsteps, other.nsteps)):
             raise ValueError("Number of steps of grids must be the same")
 
-        for name, data in other.properties_cell.items():
-            self.properties_cell[name] = data
-        for name, data in other.properties_vertex.items():
-            self.properties_vertex[name] = data
+        for name, data in other.cell_properties.items():
+            self.cell_properties[name] = data
+        for name, data in other.properties.items():
+            self.properties[name] = data
 
     def save(self, filename):
         filename = str(filename)
@@ -79,6 +79,10 @@ def save(self, filename):
 
             with open(filename, 'wb') as f:
                 pickle.dump(self, f)
+        elif ext == 'omf':
+            from LoopStructural.export.omf_wrapper import add_structured_grid_to_omf
+
+            add_structured_grid_to_omf(self, filename)
         elif ext == 'vs':
             raise NotImplementedError(
                 "Saving structured grids in gocad format is not yet implemented"

LoopStructural/export/geoh5.py

@@ -75,8 +75,8 @@ def add_structured_grid_to_geoh5(filename, structured_grid, overwrite=True, grou
             if overwrite:
                 workspace.remove_entity(existing_block[0])
         data = {}
-        if structured_grid.properties_cell is not None:
-            for k, v in structured_grid.properties_cell.items():
+        if structured_grid.cell_properties is not None:
+            for k, v in structured_grid.cell_properties.items():
                 data[k] = {
                     'association': "CELL",
                     "values": np.rot90(v.reshape(structured_grid.nsteps - 1, order="F")).flatten(),

LoopStructural/interpolators/supports/_3d_structured_grid.py

@@ -298,7 +298,6 @@ def evaluate_value(self, evaluation_points, property_array):
         v[:, :] = np.nan
         v[inside, :] = self.position_to_dof_coefs(evaluation_points[inside, :])
         v[inside, :] *= property_array[idc[inside, :]]
-
         return np.sum(v, axis=1)
 
     def evaluate_gradient(self, evaluation_points, property_array) -> np.ndarray:

LoopStructural/modelling/features/_base_geological_feature.py

@@ -318,10 +318,10 @@ def scalar_field(self, bounding_box=None):
         value = self.evaluate_value(
             self.model.scale(bounding_box.regular_grid(local=False, order='F'))
         )
-        grid.properties_vertex[self.name] = value
+        grid.properties[self.name] = value
 
         value = self.evaluate_value(bounding_box.cell_centers(order='F'))
-        grid.properties_cell[self.name] = value
+        grid.cell_properties[self.name] = value
         return grid
 
     def vector_field(self, bounding_box=None, tolerance=0.05, scale=1.0):

tests/unit/datatypes/test__structured_grid.py

@@ -15,16 +15,16 @@ def test_structured_grid_to_dict():
         origin=origin,
         step_vector=step_vector,
         nsteps=nsteps,
-        properties_vertex=data,
-        properties_cell={},
+        properties=data,
+        cell_properties={},
         name=name,
     )
     grid_dict = grid.to_dict()
 
     assert np.all(grid_dict["origin"] == origin)
     assert np.all(grid_dict["nsteps"] == nsteps)
     assert np.all(grid_dict["step_vector"] == step_vector)
-    assert np.all(grid_dict["properties_vertex"] == data)
+    assert np.all(grid_dict["properties"] == data)
     assert grid_dict["name"] == name
 
 
@@ -37,8 +37,8 @@ def test_structured_grid_maximum():
         origin=origin,
         step_vector=step_vector,
         nsteps=nsteps,
-        properties_cell={},
-        properties_vertex={},
+        cell_properties={},
+        properties={},
         name=None,
     )
     maximum = grid.maximum
@@ -62,8 +62,8 @@ def test_structured_grid_vtk():
         origin=origin,
         step_vector=step_vector,
         nsteps=nsteps,
-        properties_vertex=data,
-        properties_cell={},
+        properties=data,
+        cell_properties={},
         name=name,
     )
     vtk_grid = grid.vtk()