"Updated numpy methods to PyTorch methods in various files"

In an effort to fully transition from numpy to PyTorch, various numpy methods have been replaced with their PyTorch counterparts. This change was made to improve the overall performance and compatibility of the code. The affected files include 'backend_tensor.py', 'data_preprocess_interface.py', '_vectors_preparation.py', and '_multi_scalar_field_manager.py'. The numpy methods that were replaced include 'array', 'repeat', 'zeros', 'eye', and 'vstack'.

Author: Leguark

gempy_engine/API/interp_single/_multi_scalar_field_manager.py

@@ -60,7 +60,9 @@ def _grab_stack_fault_data(_all_stack_values_block, _interpolation_input_i, _sta
     all_scalar_fields_outputs: List[ScalarFieldOutput | None] = [None] * stack_structure.n_stacks
 
     xyz_to_interpolate_size: int = root_interpolation_input.grid.len_all_grids + root_interpolation_input.surface_points.n_points
-    all_stack_values_block: np.ndarray = np.zeros((stack_structure.n_stacks, xyz_to_interpolate_size), dtype=BackendTensor.dtype)  # * Used for faults
+    all_stack_values_block: np.ndarray = BackendTensor.t.zeros(
+        (stack_structure.n_stacks, xyz_to_interpolate_size),
+        dtype=BackendTensor.dtype_obj)  # * Used for faults
 
     for i in range(stack_structure.n_stacks):
         stack_structure.stack_number = i

gempy_engine/core/backend_tensor.py

@@ -167,8 +167,10 @@ def _repeat(tensor, n_repeats, axis=None):
         def _array(array_like, dtype=None):
             if isinstance(dtype, str):
                 dtype = getattr(torch, dtype)
-            
-            return torch.tensor(array_like, dtype=dtype)
+            if isinstance(array_like, torch.Tensor):
+                return array_like
+            else: 
+                return torch.tensor(array_like, dtype=dtype)
 
         def _concatenate(tensors, axis=0, dtype=None):
             # Switch if tensor is numpy array or a torch tensor

gempy_engine/modules/data_preprocess/data_preprocess_interface.py

@@ -27,11 +27,11 @@ def prepare_grid(grid: np.ndarray, surface_points: SurfacePoints) -> np.ndarray:
 def prepare_faults(faults_values_on_sp: np.ndarray, tensors_structure: TensorsStructure) -> Tuple[ndarray, ndarray]:
 
     partitions_bool = tensors_structure.partitions_bool
-    number_repetitions = tensors_structure.number_of_points_per_surface - 1
+    number_repetitions = bt.t.array(tensors_structure.number_of_points_per_surface - 1)
 
     ref_points = faults_values_on_sp[:, partitions_bool]
 
-    ref_matrix_val_repeated = np.repeat(ref_points, number_repetitions, 1)
+    ref_matrix_val_repeated = bt.t.repeat(ref_points, number_repetitions, 1)
     rest_matrix_val = faults_values_on_sp[:, ~partitions_bool]
 
     return ref_matrix_val_repeated, rest_matrix_val

gempy_engine/modules/kernel_constructor/_vectors_preparation.py

@@ -226,11 +226,11 @@ def _assembly_fault_internals(faults_val, options, ori_size):
     def _assembler(matrix_val, ori_size_: int, uni_drift_size: int):  # TODO: This function (probably)needs to be extracted to _kernel_constructors
         n_uni_eq = uni_drift_size  # * Number of equations. This should be how many faults are active
         n_faults = matrix_val.shape[1]  # TODO [ ]: We are going to have to tweak this for multiple faults
-        z = np.zeros((ori_size_, n_faults), dtype=BackendTensor.dtype)
-        z2 = np.zeros((n_uni_eq, n_faults), dtype=BackendTensor.dtype)
-        z3 = np.eye(n_faults, dtype=BackendTensor.dtype)
+        z = BackendTensor.t.zeros((ori_size_, n_faults), dtype=BackendTensor.dtype_obj)
+        z2 = BackendTensor.t.zeros((n_uni_eq, n_faults), dtype=BackendTensor.dtype_obj)
+        z3 = BackendTensor.t.eye(n_faults, dtype=BackendTensor.dtype_obj)
         # Degree 1
-        return np.vstack((z, matrix_val, z2, z3))
+        return BackendTensor.t.vstack((z, matrix_val, z2, z3))
 
     ref_matrix_val = faults_val.fault_values_ref
     rest_matrix_val = faults_val.fault_values_rest