[FIX] Use timestamp for cache key instead of input parameters (#23)

### TL;DR

Improved caching mechanism by using a timestamp-based approach for scalar field interpolation.

### What changed?

- Modified the cache key generation in `interpolate_scalar_field` to use a timestamp instead of multiple parameters
- Added a `start_computation_ts` field to the `TempInterpolationValues` class to store the computation start time
- Updated the `compute_model` function to set the timestamp at the beginning of computation
- Simplified error handling by raising a ValueError when cache is corrupted instead of attempting to recalculate weights

### How to test?

1. Run a model computation and verify that caching works correctly
2. Run multiple computations in sequence to ensure the timestamp-based caching properly identifies different computation runs
3. Test cache invalidation by modifying input data between runs

### Why make this change?

The previous caching mechanism relied on multiple parameters which could lead to unnecessary cache misses or complex hash generation. Using a timestamp simplifies the caching logic while still providing a unique identifier for each computation run. This approach is more efficient and reduces the risk of cache-related bugs.

Author: Leguark

gempy_engine/API/interp_single/_interp_scalar_field.py

@@ -1,3 +1,5 @@
+import warnings
+
 from typing import Tuple, Optional
 
 import numpy as np
@@ -29,15 +31,17 @@ def interpolate_scalar_field(solver_input: SolverInput, options: InterpolationOp
                 key=weights_key,
                 look_in_disk= not options.cache_mode == InterpolationOptions.CacheMode.IN_MEMORY_CACHE
             )
-            weights_hash = generate_cache_key(
-                name="",
-                parameters={
-                        "surface_points": solver_input.sp_internal,
-                        "orientations"  : solver_input.ori_internal,
-                        "fault_internal": solver_input._fault_internal.fault_values_on_sp,
-                        "kernel_options": options.kernel_options
-                }
-            )
+            ts = options.temp_interpolation_values.start_computation_ts
+            if ts == -1:
+                warnings.warn("No start computation timestamp found. No caching.")
+                weights_cached = None
+            else:
+                weights_hash = generate_cache_key(
+                    name="",
+                    parameters={
+                            "ts": ts
+                    }
+                )
         case  InterpolationOptions.CacheMode.CLEAR_CACHE:
             WeightCache.initialize_cache_dir()
             weights_cached = None
@@ -54,9 +58,7 @@ def interpolate_scalar_field(solver_input: SolverInput, options: InterpolationOp
                 weights_key=weights_key,
                 weights_hash=weights_hash
             )
-
         case _ if weights_cached["hash"] != weights_hash:
-            solver_input.weights_x0 = weights_cached["weights"]
             weights = _solve_and_store_weights(
                 solver_input=solver_input,
                 kernel_options=options.kernel_options,

gempy_engine/API/model/model_api.py

@@ -1,3 +1,4 @@
+import time
 import copy
 from typing import List, Optional
 
@@ -15,63 +16,70 @@
 from ...core.data.input_data_descriptor import InputDataDescriptor
 from ...core.data.interpolation_input import InterpolationInput
 from ...core.utils import gempy_profiler_decorator
-
-
+from ...modules.weights_cache.weights_cache_interface import WeightCache
 
 
 @gempy_profiler_decorator
 def compute_model(interpolation_input: InterpolationInput, options: InterpolationOptions,
                   data_descriptor: InputDataDescriptor, *, geophysics_input: Optional[GeophysicsInput] = None) -> Solutions:
 
-    # ! If we inline this it seems the deepcopy does not work
-    if BackendTensor.engine_backend is not AvailableBackends.PYTORCH and NOT_MAKE_INPUT_DEEP_COPY is False:
-        interpolation_input = copy.deepcopy(interpolation_input)
+    try:
+        WeightCache.initialize_cache_dir()
+        options.temp_interpolation_values.start_computation_ts = int(time.time())
 
-    # Check input is valid
-    _check_input_validity(interpolation_input, options, data_descriptor)
-
-    output: list[OctreeLevel] = interpolate_n_octree_levels(
-        interpolation_input=interpolation_input,
-        options=options,
-        data_descriptor=data_descriptor
-    )
-    # region Geophysics
-    # ---------------------
-    # TODO: [x] Gravity
-    # TODO: [ ] Magnetics
-
-    if geophysics_input is not None:
-        first_level_last_field: InterpOutput = output[0].outputs_centers[-1]
-        gravity = compute_gravity(
-            geophysics_input=geophysics_input,
-            root_ouput=first_level_last_field
-        )
-    else:
-        gravity = None
-
-    # endregion
+        # ! If we inline this it seems the deepcopy does not work
+        if BackendTensor.engine_backend is not AvailableBackends.PYTORCH and NOT_MAKE_INPUT_DEEP_COPY is False:
+            interpolation_input = copy.deepcopy(interpolation_input)
+            
+        # Check input is valid
+        _check_input_validity(interpolation_input, options, data_descriptor)
 
-    meshes: Optional[list[DualContouringMesh]] = None
-    if options.mesh_extraction:
-        if interpolation_input.grid.octree_grid is None:
-            raise ValueError("Octree grid must be defined to extract the mesh")
-        
-        meshes: list[DualContouringMesh] = dual_contouring_multi_scalar(
-            data_descriptor=data_descriptor,
+        output: list[OctreeLevel] = interpolate_n_octree_levels(
             interpolation_input=interpolation_input,
             options=options,
-            octree_list=output[:options.number_octree_levels_surface]
+            data_descriptor=data_descriptor
         )
+        # region Geophysics
+        # ---------------------
+        # TODO: [x] Gravity
+        # TODO: [ ] Magnetics
+
+        if geophysics_input is not None:
+            first_level_last_field: InterpOutput = output[0].outputs_centers[-1]
+            gravity = compute_gravity(
+                geophysics_input=geophysics_input,
+                root_ouput=first_level_last_field
+            )
+        else:
+            gravity = None
+
+        # endregion
 
-    solutions = Solutions(
-        octrees_output=output,
-        dc_meshes=meshes,
-        fw_gravity=gravity,
-        block_solution_type=options.block_solutions_type
-    )
+        meshes: Optional[list[DualContouringMesh]] = None
+        if options.mesh_extraction:
+            if interpolation_input.grid.octree_grid is None:
+                raise ValueError("Octree grid must be defined to extract the mesh")
+            
+            meshes: list[DualContouringMesh] = dual_contouring_multi_scalar(
+                data_descriptor=data_descriptor,
+                interpolation_input=interpolation_input,
+                options=options,
+                octree_list=output[:options.number_octree_levels_surface]
+            )
+
+        solutions = Solutions(
+            octrees_output=output,
+            dc_meshes=meshes,
+            fw_gravity=gravity,
+            block_solution_type=options.block_solutions_type
+        )
 
-    if options.debug:
-        solutions.debug_input_data["stack_interpolation_input"] = interpolation_input
+        if options.debug:
+            solutions.debug_input_data["stack_interpolation_input"] = interpolation_input
+    except Exception as e:
+        raise e
+    finally:
+        options.temp_interpolation_values.start_computation_ts = -1
 
     return solutions
 

gempy_engine/core/data/options/temp_interpolation_values.py

@@ -4,3 +4,4 @@
 @dataclass
 class TempInterpolationValues:
     current_octree_level: int = 0  # * Make this a read only property 
+    start_computation_ts: int = -1

gempy_engine/modules/evaluator/generic_evaluator.py

@@ -72,7 +72,10 @@ def _eval_on(
     eval_kernel = yield_evaluation_kernel(
         solver_input, options.kernel_options, slice_array=slice_array
     )
-    scalar_field = (eval_kernel.T @ weights).reshape(-1)
+    try:
+        scalar_field = (eval_kernel.T @ weights).reshape(-1)
+    except ValueError:
+        pass
 
     gx_field: Optional[np.ndarray] = None
     gy_field: Optional[np.ndarray] = None

tests/fixtures/complex_geometries.py

@@ -83,6 +83,7 @@ def one_fault_model():
         number_dimensions=3,
         kernel_function=AvailableKernelFunctions.exponential)
 
+    options.cache_mode = InterpolationOptions.CacheMode.NO_CACHE
     # endregion
 
     return interpolation_input, input_data_descriptor, options

tests/fixtures/simple_geometries.py

@@ -49,7 +49,7 @@ def unconformity() -> Tuple[InterpolationInput, InterpolationOptions, InputDataD
     options = InterpolationOptions.from_args(range_, c_o, uni_degree=1, i_res=i_r, gi_res=gi_r,
                                    number_dimensions=3,
                                    kernel_function=AvailableKernelFunctions.cubic)
-
+    options.cache_mode = InterpolationOptions.CacheMode.NO_CACHE
     resolution = [2, 2, 2]
     extent = [0, 1000, 0, 1000, 0, 1000]
 

tests/fixtures/simple_models.py

@@ -33,6 +33,7 @@
 from gempy_engine.modules.data_preprocess._input_preparation import surface_points_preprocess, \
     orientations_preprocess
 
+
 np.set_printoptions(precision=3, linewidth=200)
 
 dir_name = os.path.dirname(__file__)
@@ -136,6 +137,9 @@ def _gen():
 
 
 def simple_model_interpolation_input_factory():
+    from gempy_engine.modules.weights_cache.weights_cache_interface import WeightCache
+    WeightCache.initialize_cache_dir()
+    
     resolution = [2, 2, 3]
     extent = [0.25, .75, 0.25, .75, 0.25, .75]
 
@@ -165,6 +169,7 @@ def simple_model_interpolation_input_factory():
     ori_i = Orientations(dip_positions, dip_gradients, nugget_effect_grad)
     interpolation_options = InterpolationOptions.from_args(range_, co, 0, number_dimensions=3,
                                                  kernel_function=AvailableKernelFunctions.cubic)
+    interpolation_options.cache_mode = InterpolationOptions.CacheMode.NO_CACHE
     ids = np.array([1, 2])
     interpolation_input = InterpolationInput(spi, ori_i, grid_0_centers, ids)
     tensor_struct = TensorsStructure(np.array([7]))
@@ -189,6 +194,10 @@ def simple_model_3_layers(simple_grid_3d_octree) -> Tuple[InterpolationInput, In
 
 
 def _gen_simple_model_3_layers(simple_grid_3d_octree):
+
+    from gempy_engine.modules.weights_cache.weights_cache_interface import WeightCache
+    WeightCache.initialize_cache_dir() 
+    
     grid_0_centers = dataclasses.replace(simple_grid_3d_octree)
     np.set_printoptions(precision=3, linewidth=200)
     dip_positions = np.array([
@@ -232,6 +241,8 @@ def _gen_simple_model_3_layers(simple_grid_3d_octree):
 
 @pytest.fixture(scope="session")
 def simple_model_3_layers_high_res(simple_grid_3d_more_points_grid) -> Tuple[InterpolationInput, InterpolationOptions, InputDataDescriptor]:
+    from gempy_engine.modules.weights_cache.weights_cache_interface import WeightCache 
+    WeightCache.initialize_cache_dir() 
     grid_0_centers = dataclasses.replace(simple_grid_3d_more_points_grid)
 
     np.set_printoptions(precision=3, linewidth=200)
@@ -269,6 +280,7 @@ def simple_model_3_layers_high_res(simple_grid_3d_more_points_grid) -> Tuple[Int
 
     interpolation_options = InterpolationOptions.from_args(range_, co, 0,
                                                  number_dimensions=3, kernel_function=AvailableKernelFunctions.cubic)
+    interpolation_options.cache_mode = InterpolationOptions.CacheMode.NO_CACHE
 
     ids = np.array([1, 2, 3, 4])
 

tests/test_common/test_api/test_faults/test_one_fault.py

@@ -107,6 +107,9 @@ def test_one_fault_model_thickness(one_fault_model, n_oct_levels=2):
 
 
 def test_one_fault_model_finite_fault(one_fault_model, n_oct_levels=4):
+    from gempy_engine.modules.weights_cache.weights_cache_interface import WeightCache
+    WeightCache.initialize_cache_dir()
+    
     interpolation_input: InterpolationInput
     structure: InputDataDescriptor
     options: InterpolationOptions
@@ -171,6 +174,9 @@ def test_one_fault_model_finite_fault(one_fault_model, n_oct_levels=4):
 
 
 def test_implicit_ellipsoid_projection_on_fault(one_fault_model):
+    from gempy_engine.modules.weights_cache.weights_cache_interface import WeightCache
+    WeightCache.initialize_cache_dir()
+    
     interpolation_input: InterpolationInput
     structure: InputDataDescriptor
     options: InterpolationOptions

tests/test_common/test_integrations/test_interpolate_model.py

@@ -12,6 +12,9 @@
 
 
 def test_interpolate_model(simple_model_interpolation_input, n_oct_levels=3):
+
+    from gempy_engine.modules.weights_cache.weights_cache_interface import WeightCache
+    WeightCache.initialize_cache_dir()
     """Kernel function Cubic"""
     interpolation_input, options, structure = simple_model_interpolation_input
     print(interpolation_input)
@@ -29,6 +32,9 @@ def test_interpolate_model(simple_model_interpolation_input, n_oct_levels=3):
 
 @pytest.mark.skipif(TEST_SPEED.value <= 1, reason="Global test speed below this test value.")
 def test_interpolate_model_no_octtree(simple_model_3_layers_high_res, n_oct_levels=2):
+
+    from gempy_engine.modules.weights_cache.weights_cache_interface import WeightCache
+    WeightCache.initialize_cache_dir()
     interpolation_input, options, structure = simple_model_3_layers_high_res
     print(interpolation_input)
 
@@ -44,6 +50,9 @@ def test_interpolate_model_no_octtree(simple_model_3_layers_high_res, n_oct_leve
 
 
 def test_interpolate_model_several_surfaces(simple_model_3_layers, n_oct_levels=3):
+
+    from gempy_engine.modules.weights_cache.weights_cache_interface import WeightCache
+    WeightCache.initialize_cache_dir()
     interpolation_input, options, structure = simple_model_3_layers
     print(interpolation_input)
 
@@ -63,6 +72,9 @@ def test_interpolate_model_several_surfaces(simple_model_3_layers, n_oct_levels=
 
 
 def test_interpolate_model_unconformity(unconformity, n_oct_levels=4):
+    from gempy_engine.modules.weights_cache.weights_cache_interface import WeightCache
+    WeightCache.initialize_cache_dir()
+
     interpolation_input, options, structure = unconformity
     print(interpolation_input)