From 4b165614501b1194be8f07dc2a723cac07f6aee7 Mon Sep 17 00:00:00 2001 From: rabii-chaarani Date: Tue, 21 May 2024 03:37:06 +0000 Subject: [PATCH] style: style fixes by ruff and autoformatting by black --- FoldOptLib/fold_modelling/engine.py | 23 ++++++---- FoldOptLib/input/data_storage.py | 22 +++++++--- FoldOptLib/input/input_data_processor.py | 1 - tests/unit/fold_model/test_engine.py | 53 +++++++++++++++++------- 4 files changed, 70 insertions(+), 29 deletions(-) diff --git a/FoldOptLib/fold_modelling/engine.py b/FoldOptLib/fold_modelling/engine.py index c36d2ea..6d5dcb7 100644 --- a/FoldOptLib/fold_modelling/engine.py +++ b/FoldOptLib/fold_modelling/engine.py @@ -15,7 +15,6 @@ from ..from_loopstructural._fold_frame import FoldFrame from .base_engine import BaseEngine from ..optimisers import FourierSeriesOptimiser -from LoopStructural.utils._transformation import EuclideanTransformation import gc @@ -114,7 +113,9 @@ def initialise_model(self) -> None: self.points ) # EuclideanTransformation(dimensions=self.dimensions).fit_transform(self.points) - def process_axial_surface_proposition(self, axial_normal: numpy.ndarray) -> pandas.DataFrame: + def process_axial_surface_proposition( + self, axial_normal: numpy.ndarray + ) -> pandas.DataFrame: """ Process the axial surface proposition at each iteration by creating a dataset from the axial surface normal. @@ -194,9 +195,9 @@ def create_and_build_fold_event(self) -> FoldEvent: foldframe = FoldFrame("sn", self.axial_surface) # calculate the gradient of the axial surface - s1g = self.axial_surface[CoordinateType.AXIAL_FOLIATION_FIELD].evaluate_gradient( - self.scaled_points - ) + s1g = self.axial_surface[ + CoordinateType.AXIAL_FOLIATION_FIELD + ].evaluate_gradient(self.scaled_points) # normalise the gradient s1g /= numpy.linalg.norm(s1g, axis=1)[:, None] @@ -242,7 +243,9 @@ def create_and_build_fold_event(self) -> FoldEvent: fold_axis_rotation_function = fold_function(fitted_far) # create a fold event with the axial surface and fold axis rotation function - fold = FoldEvent(self.axial_surface, fold_axis_rotation=fold_axis_rotation_function) + fold = FoldEvent( + self.axial_surface, fold_axis_rotation=fold_axis_rotation_function + ) # calculate the fold limb rotation angle flr, fld = foldframe.calculate_fold_limb_rotation( @@ -371,7 +374,9 @@ def fit_fourier_series( return opt.x else: - fourier_optimiser = FourierSeriesOptimiser(fold_frame_coordinate, rotation_angle, x) + fourier_optimiser = FourierSeriesOptimiser( + fold_frame_coordinate, rotation_angle, x + ) # Optimise the Fourier series opt = fourier_optimiser.optimise() @@ -395,7 +400,9 @@ def calculate_folded_foliation_vectors(self) -> numpy.ndarray: s1g /= numpy.linalg.norm(s1g, axis=1)[:, None] # Get deformed orientation and normalize the fold direction - fold_direction, fold_axis, gz = fold.get_deformed_orientation(self.scaled_points) + fold_direction, fold_axis, gz = fold.get_deformed_orientation( + self.scaled_points + ) fold_direction /= numpy.linalg.norm(fold_direction, axis=1)[:, None] # Correct any fold_direction vector to be consistent with the axial surface orientation diff --git a/FoldOptLib/input/data_storage.py b/FoldOptLib/input/data_storage.py index 2b75460..8c5ef58 100644 --- a/FoldOptLib/input/data_storage.py +++ b/FoldOptLib/input/data_storage.py @@ -137,9 +137,14 @@ def set_axial_surface_field_constraints(self): mean_x, mean_y, mean_z = self.axial_normals()[["X", "Y", "Z"]].mean(0) min_x, min_y, min_z = self.axial_normals()[["X", "Y", "Z"]].min(0) max_x, max_y, max_z = self.axial_normals()[["X", "Y", "Z"]].max(0) - value_constraints = numpy.array([[mean_x, mean_y, mean_z, 0.0, 1.0], - [min_x, min_y, min_z, -1.0, 1.0], - [max_x, max_y, max_z, 1.0, 1.0]], dtype=float) + value_constraints = numpy.array( + [ + [mean_x, mean_y, mean_z, 0.0, 1.0], + [min_x, min_y, min_z, -1.0, 1.0], + [max_x, max_y, max_z, 1.0, 1.0], + ], + dtype=float, + ) normal_constraints = self.axial_normals()[ ["X", "Y", "Z", "gx", "gy", "gz", "weight"] @@ -163,9 +168,14 @@ def set_fold_axis_field_constraints(self): mean_x, mean_y, mean_z = self.y_normals()[["X", "Y", "Z"]].mean(0) min_x, min_y, min_z = self.y_normals()[["X", "Y", "Z"]].min(0) max_x, max_y, max_z = self.y_normals()[["X", "Y", "Z"]].max(0) - value_constraints = numpy.array([[mean_x, mean_y, mean_z, 0.0, 1.0], - [min_x, min_y, min_z, -1.0, 1.0], - [max_x, max_y, max_z, 1.0, 1.0]], dtype=float) + value_constraints = numpy.array( + [ + [mean_x, mean_y, mean_z, 0.0, 1.0], + [min_x, min_y, min_z, -1.0, 1.0], + [max_x, max_y, max_z, 1.0, 1.0], + ], + dtype=float, + ) normal_constraints = self.y_normals()[ ["X", "Y", "Z", "gx", "gy", "gz", "weight"] diff --git a/FoldOptLib/input/input_data_processor.py b/FoldOptLib/input/input_data_processor.py index 8acc604..ed1aeee 100644 --- a/FoldOptLib/input/input_data_processor.py +++ b/FoldOptLib/input/input_data_processor.py @@ -48,7 +48,6 @@ def __post_init__(self): else: raise ValueError("Data must be a pandas DataFrame.") - @staticmethod def normalise(gradient: numpy.ndarray) -> numpy.ndarray: """Normalise vectors.""" diff --git a/tests/unit/fold_model/test_engine.py b/tests/unit/fold_model/test_engine.py index 1828aae..2d7e721 100644 --- a/tests/unit/fold_model/test_engine.py +++ b/tests/unit/fold_model/test_engine.py @@ -7,16 +7,17 @@ from FoldOptLib.builders import FoldFrameBuilder, Builder from LoopStructural import BoundingBox + # Sample data for tests @pytest.fixture def sample_data(): data = { - "gx": [0., 0., 0.], - "gy": [0., 0.5, 0.1], + "gx": [0.0, 0.0, 0.0], + "gy": [0.0, 0.5, 0.1], "gz": [0.5, 0.4, 0.5], "X": [10, 11, 12], "Y": [13, 14, 15], - "Z": [16, 17, 18], + "Z": [16, 17, 18], "feature_name": ["feature", "feature", "feature"], "weight": [1, 1, 1], } @@ -26,25 +27,38 @@ def sample_data(): return input_data + @pytest.fixture def fold_model(sample_data): return FoldModel(sample_data) + def test_initialization(fold_model, sample_data): assert fold_model.raw_data is sample_data assert fold_model.bounding_box is sample_data[DataType.BOUNDING_BOX] assert fold_model.model is None # Ensure the columns are present - assert 'weight' in sample_data[DataType.DATA].columns, "'weight' column is missing from sample_data" - np.testing.assert_array_equal(fold_model.gradient_data, sample_data[DataType.DATA][["gx", "gy", "gz"]].to_numpy()) - np.testing.assert_array_equal(fold_model.points, sample_data[DataType.DATA][["X", "Y", "Z"]].to_numpy()) + assert ( + "weight" in sample_data[DataType.DATA].columns + ), "'weight' column is missing from sample_data" + np.testing.assert_array_equal( + fold_model.gradient_data, + sample_data[DataType.DATA][["gx", "gy", "gz"]].to_numpy(), + ) + np.testing.assert_array_equal( + fold_model.points, sample_data[DataType.DATA][["X", "Y", "Z"]].to_numpy() + ) assert fold_model.axial_surface is None assert fold_model.scaled_points is None + def test_set_data(fold_model, sample_data): - + fold_model.set_data(sample_data) - np.testing.assert_array_equal(fold_model.data[["gx"]], sample_data[DataType.DATA][["gx"]]) + np.testing.assert_array_equal( + fold_model.data[["gx"]], sample_data[DataType.DATA][["gx"]] + ) + def test_initialise_model(fold_model): fold_model.initialise_model() @@ -52,26 +66,37 @@ def test_initialise_model(fold_model): assert fold_model.scaled_points is not None assert fold_model.geological_knowledge is None + def test_process_axial_surface_proposition(fold_model, sample_data): fold_model.initialise_model() - axial_normal = np.array([1., 0., 0.], dtype=float) - np.testing.assert_array_equal(fold_model.points, sample_data[DataType.DATA][["X", "Y", "Z"]].to_numpy()) + axial_normal = np.array([1.0, 0.0, 0.0], dtype=float) + np.testing.assert_array_equal( + fold_model.points, sample_data[DataType.DATA][["X", "Y", "Z"]].to_numpy() + ) result = fold_model.process_axial_surface_proposition(axial_normal) assert isinstance(result, OptData) + def test_build_fold_frame(fold_model, sample_data): fold_model.initialise_model() # Ensure the columns are present - assert 'weight' in fold_model.raw_data[DataType.DATA].columns, "'weight' column is missing from sample_data" - axial_normal = np.array([1., 0., 0.], dtype=float) - np.testing.assert_array_equal(fold_model.points, sample_data[DataType.DATA][["X", "Y", "Z"]].to_numpy()) + assert ( + "weight" in fold_model.raw_data[DataType.DATA].columns + ), "'weight' column is missing from sample_data" + axial_normal = np.array([1.0, 0.0, 0.0], dtype=float) + np.testing.assert_array_equal( + fold_model.points, sample_data[DataType.DATA][["X", "Y", "Z"]].to_numpy() + ) result = fold_model.process_axial_surface_proposition(axial_normal) assert isinstance(result, OptData) fold_model.build_fold_frame(axial_normal) assert isinstance(fold_model.axial_surface, FoldFrameBuilder) - assert isinstance(fold_model.axial_surface[CoordinateType.AXIAL_FOLIATION_FIELD], Builder) + assert isinstance( + fold_model.axial_surface[CoordinateType.AXIAL_FOLIATION_FIELD], Builder + ) assert isinstance(fold_model.axial_surface[CoordinateType.FOLD_AXIS_FIELD], Builder) + # def test_create_and_build_fold_event(fold_model): # fold_model.initialise_model() # axial_normal = np.array([1., 0., 0.], dtype=float)