From dab8c1ababbe3f1f4ae9a13bceb1fbf5b1f46e61 Mon Sep 17 00:00:00 2001 From: Nayane Fernandes <143632290+ansnfernand@users.noreply.github.com> Date: Tue, 16 Jul 2024 16:34:40 +0200 Subject: [PATCH 1/7] New API: export_FEA_model() --- doc/source/api/index.rst | 2 + doc/source/api/model_types.rst | 21 + src/ansys/sherlock/core/errors.py | 13 + src/ansys/sherlock/core/model.py | 276 +++++++- src/ansys/sherlock/core/types/model_types.py | 65 ++ tests/test_model.py | 691 ++++++++++++++++++- 6 files changed, 1066 insertions(+), 2 deletions(-) create mode 100644 doc/source/api/model_types.rst create mode 100644 src/ansys/sherlock/core/types/model_types.py diff --git a/doc/source/api/index.rst b/doc/source/api/index.rst index a59bb8952..2f245ea14 100644 --- a/doc/source/api/index.rst +++ b/doc/source/api/index.rst @@ -17,6 +17,7 @@ Use the search feature or click links to view API documentation. layer lifecycle model + model_types parts layer_types parts_types @@ -32,6 +33,7 @@ Use the search feature or click links to view API documentation. ansys.sherlock.core.layer ansys.sherlock.core.lifecycle ansys.sherlock.core.model + ansys.sherlock.core.types.model_types ansys.sherlock.core.parts ansys.sherlock.core.types.layer_types ansys.sherlock.core.types.parts_types diff --git a/doc/source/api/model_types.rst b/doc/source/api/model_types.rst new file mode 100644 index 000000000..d0922323c --- /dev/null +++ b/doc/source/api/model_types.rst @@ -0,0 +1,21 @@ +.. _ref_model_types: + +Model Types +=========== + +Classes used for the Model API. + +.. currentmodule:: ansys.sherlock.core.types.model_types + +.. autosummary:: + :toctree: _autosummary + + MaxEdgeLength + MaxMeshSize + MinHoleDiameter + VerticalMeshSize + +Constants +--------- +.. autoclass:: ExportFEAModelAnalysisType + :members: diff --git a/src/ansys/sherlock/core/errors.py b/src/ansys/sherlock/core/errors.py index 289e20370..a28d59429 100644 --- a/src/ansys/sherlock/core/errors.py +++ b/src/ansys/sherlock/core/errors.py @@ -1171,3 +1171,16 @@ def __init__(self, message): def __str__(self): """Format error message.""" return f"Create CCA from modeling region error: {self.message}" + + +class SherlockExportFEAModelError(Exception): + """Contains the error raised when a FEA model cannot be exported.""" + + def __init__(self, message): + """Initialize error message.""" + self.message = message + + def __str__(self): + """Format error message.""" + return f"Export FEA model error: {self.message}" + diff --git a/src/ansys/sherlock/core/model.py b/src/ansys/sherlock/core/model.py index dddd84815..f83eabd78 100644 --- a/src/ansys/sherlock/core/model.py +++ b/src/ansys/sherlock/core/model.py @@ -12,9 +12,21 @@ from ansys.api.sherlock.v0 import SherlockModelService_pb2_grpc from ansys.api.sherlock.v0 import SherlockAnalysisService_pb2 +from typing import List + from ansys.sherlock.core import LOG -from ansys.sherlock.core.errors import SherlockExportAEDBError, SherlockModelServiceError +from ansys.sherlock.core.errors import ( + SherlockExportAEDBError, + SherlockExportFEAModelError, + SherlockModelServiceError, +) from ansys.sherlock.core.grpc_stub import GrpcStub +from ansys.sherlock.core.types.model_types import ( + MaxEdgeLength, + MaxMeshSize, + MinHoleDiameter, + VerticalMeshSize, +) class Model(GrpcStub): @@ -632,3 +644,265 @@ def createExportTraceCopperLayerParams( dhm.maxEdgeLength.units = drill_hole_max_edge_length_units return ret + + def export_FEA_model( + self, + project: str, + cca_name: str, + export_file: str, + analysis: int, + drill_hole_parameters: List[dict], + detect_lead_modeling: str, + lead_model_parameters: List[dict], + display_model: bool, + clear_FEA_database: bool, + use_FEA_model_id: bool, + coordinate_units: str, + ): + """ + Export a FEA model. + + Parameters + ---------- + project : str + Name of the Sherlock project. + cca_name : str + Name of the CCA. + export_file : str + Full path for saving exported files to. The file extension must be ``".wbjn"``. + analysis : ExportFEAModelAnalysisType + The type of analysis is being exported. + drill_hole_parameters : list + List of the drill hole parameters consisting of these properties: + + - drill_hole_modeling : str + The status of the drill hole modeling feature. If enabled, automatically enable + drill hole modeling. Valid values are ``ENABLED/enabled`` or + ``DISABLED/disabled``. + - min_hole_diameter : MinHoleDiameter + The properties of the minimum hole diameter. + - max_edge_length : MaxEdgeLength + The properties of the maximum edge length. + detect_lead_modeling : str + The status of the detect lead modeling feature. If enabled, automatically enable lead + modeling if any part has lead geometry defined. Valid values are ``ENABLED/enabled`` or + ``DISABLED/disabled``. + lead_model_parameters : list + List of the lead model parameters consisting of these properties: + + - lead_modeling : str + The status of the lead modeling feature. If enabled, automatically enable lead + modeling. Valid values are ``ENABLED/enabled`` or ``DISABLED/disabled``. + - lead_element_order : str + The type of the element order. Valid values are ``First Order (Linear)``, + ``Second Order (Quadratic)``, or ``Solid Shell``. + - max_mesh_size : MaxMeshSize + The properties of the maximum mesh size. + - vertical_mesh_size : VerticalMeshSize + The properties of the vertical mesh size. + - thicknessCount : int, optional + The number of elements through the lead thickness that will be created per lead. + The default value is 3 and the maximum is 5. Only used when the advanced lead + mesh setting is enabled. + - aspectRatio : int, optional + The aspect ratio is multiplied by the lead thickness divided by the through + thickness count to give the lead element height. The default value is 2 and the + maximum is 10. Only used when the advanced lead mesh setting is enabled. + display_model : bool + Whether to display the model after export. + clear_FEA_database : bool + Whether to clear FEA database before defining model. + use_FEA_model_id : bool + Whether to use FEA model ID. + coordinate_units : str + Units of the model coordinates to use when exporting a model. + + + Returns + ------- + int + Status code of the response. 0 for success. + + Examples + -------- + >>> from ansys.sherlock.core.launcher import launch_sherlock + >>> from ansys.sherlock.core.types.model_types import ( + ExportFEAModelAnalysisType, + MaxEdgeLength, + MaxMeshSize, + MinHoleDiameter, + VerticalMeshSize, + ) + >>> sherlock = launch_sherlock() + >>> sherlock.model.export_FEA_model( + project="Test Project", + cca_name="Main Board", + export_file="C:/Temp/export.wbjn", + analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + drill_hole_parameters=[ + { + "drill_hole_modeling": "ENABLED", + "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), + "max_edge_length": MaxEdgeLength(value=1.0, unit="mm") + } + ], + detect_lead_modeling="ENABLED", + lead_model_parameters=[ + { + "lead_modeling": "ENABLED", + "lead_element_order": "First Order (Linear)", + "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), + "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "thicknessCount": 3, + "aspectRatio": 2 + } + ], + display_model=True, + clear_FEA_database=True, + use_FEA_model_id=True, + coordinate_units="mm" + ) + """ + try: + if not project: + raise SherlockExportFEAModelError(message="Project name is invalid.") + + if not cca_name: + raise SherlockExportFEAModelError(message="CCA name is invalid.") + + if not export_file: + raise SherlockExportFEAModelError(message="Export file path is invalid.") + + if not os.path.exists(os.path.dirname(export_file)): + raise SherlockExportFEAModelError( + message=f"Export file directory " f'"{export_file}" ' f"does not exist." + ) + + if not isinstance(analysis, int) or analysis == "": + raise SherlockExportFEAModelError(message=f"Analysis for FEA model is invalid.") + + for param in drill_hole_parameters: + drill_hole_modeling = param.get("drill_hole_modeling") + if drill_hole_modeling not in ["ENABLED", "enabled", "DISABLED", "disabled"]: + raise SherlockExportFEAModelError( + message="Drill hole modeling status " "is invalid." + ) + + min_hole_diameter = param.get("min_hole_diameter") + if not isinstance(min_hole_diameter, MinHoleDiameter): + raise SherlockExportFEAModelError(message="Minimum hole diameter is invalid.") + + max_edge_length = param.get("max_edge_length") + if not isinstance(max_edge_length, MaxEdgeLength): + raise SherlockExportFEAModelError(message="Maximum edge length is invalid.") + + if detect_lead_modeling not in ["ENABLED", "enabled", "DISABLED", "disabled"]: + raise SherlockExportFEAModelError(message="Detect lead modeling status is invalid.") + + for param in lead_model_parameters: + lead_modeling = param.get("lead_modeling") + if lead_modeling not in ["ENABLED", "enabled", "DISABLED", "disabled"]: + raise SherlockExportFEAModelError(message="Lead modeling status is invalid.") + + lead_element_order = param.get("lead_element_order") + if lead_element_order not in [ + "First Order (Linear)", + "Second Order (Quadratic)", + "Solid Shell", + ]: + raise SherlockExportFEAModelError(message="Lead element order is invalid.") + + max_mesh_size = param.get("max_mesh_size") + if not isinstance(max_mesh_size, MaxMeshSize): + raise SherlockExportFEAModelError(message="Maximum mesh size is invalid.") + + vertical_mesh_size = param.get("vertical_mesh_size") + if not isinstance(vertical_mesh_size, VerticalMeshSize): + raise SherlockExportFEAModelError(message="Vertical mesh size is invalid.") + + thickness_count = param.get("thicknessCount", 3) + if ( + not isinstance(thickness_count, int) + or thickness_count < 1 + or thickness_count > 5 + ): + raise SherlockExportFEAModelError( + message="Invalid thickness count. Must be an integer between 1 and 5, with " + "a default value of 3." + ) + + aspect_ratio = param.get("aspectRatio", 2) + if not isinstance(aspect_ratio, int) or aspect_ratio < 1 or aspect_ratio > 10: + raise SherlockExportFEAModelError( + message="Invalid aspect ratio. Must be an integer between 1 and 10, with " + "a default value of 2." + ) + + if not isinstance(display_model, bool): + raise SherlockExportFEAModelError(message="display_model must be a boolean.") + + if not isinstance(clear_FEA_database, bool): + raise SherlockExportFEAModelError(message="clear_FEA_database must be a boolean.") + + if not isinstance(use_FEA_model_id, bool): + raise SherlockExportFEAModelError(message="use_FEA_model_id must be a boolean.") + + if not isinstance(coordinate_units, str): + raise SherlockExportFEAModelError(message="coordinate_units must be a string.") + + if not self._is_connection_up(): + LOG.error("There is no connection to a gRPC service.") + return + + export_request = SherlockModelService_pb2.ExportFEAModelRequest() + export_request.project = project + export_request.ccaName = cca_name + export_request.exportFile = export_file + export_request.analysis = analysis + + for param in drill_hole_parameters: + export_request.drillHoleParam.drillHoleModeling = param.get("drill_hole_modeling") + + min_hole_diameter = param.get("min_hole_diameter") + export_request.drillHoleParam.minHoleDiameter.value = min_hole_diameter.value + export_request.drillHoleParam.minHoleDiameter.unit = min_hole_diameter.unit + + max_edge_length = param.get("max_edge_length") + export_request.drillHoleParam.maxEdgeLength.value = max_edge_length.value + export_request.drillHoleParam.maxEdgeLength.unit = max_edge_length.unit + + export_request.detectLeadModeling = detect_lead_modeling + + for param in lead_model_parameters: + export_request.leadModelParam.leadModeling = param.get("lead_modeling") + + export_request.leadModelParam.leadElemOrder = param.get("lead_element_order") + + max_mesh_size = param.get("max_mesh_size") + export_request.leadModelParam.maxMeshSize.value = max_mesh_size.value + export_request.leadModelParam.maxMeshSize.unit = max_mesh_size.unit + + vertical_mesh_size = param.get("vertical_mesh_size") + export_request.leadModelParam.verticalMeshSize.value = vertical_mesh_size.value + export_request.leadModelParam.verticalMeshSize.unit = vertical_mesh_size.unit + + thickness_count = param.get("thicknessCount", 3) + export_request.leadModelParam.thicknessCount = thickness_count + + aspect_ratio = param.get("aspectRatio", 2) + export_request.leadModelParam.aspectRatio = aspect_ratio + + export_request.displayModel = display_model + export_request.clearFEADatabase = clear_FEA_database + export_request.useFEAModelID = use_FEA_model_id + export_request.coordinateUnits = coordinate_units + + return_code = self.stub.exportFEAModel(export_request) + if return_code.value != 0: + raise SherlockExportFEAModelError(message=return_code.message) + + return return_code.value + + except SherlockExportFEAModelError as e: + LOG.error(str(e)) + raise e diff --git a/src/ansys/sherlock/core/types/model_types.py b/src/ansys/sherlock/core/types/model_types.py new file mode 100644 index 000000000..312e5a513 --- /dev/null +++ b/src/ansys/sherlock/core/types/model_types.py @@ -0,0 +1,65 @@ +# © 2024 ANSYS, Inc. All rights reserved. + +"""Module containing types for the Model Service.""" + +try: + import SherlockModelService_pb2 +except ModuleNotFoundError: + from ansys.api.sherlock.v0 import SherlockModelService_pb2 + +model_service = SherlockModelService_pb2 + + +class ExportFEAModelAnalysisType: + """Constants for type of analysis in the Export FEA Model request.""" + + __analysis_type = model_service.ExportFEAModelRequest.ExportAnalysis + NATURAL_FREQUENCY = __analysis_type.NaturalFreq + HARMONIC_VIBE = __analysis_type.HarmonicVibe + ICT = __analysis_type.ICTAnalysis + MECHANICAL_SHOCK = __analysis_type.MechanicalShock + RANDOM_VIBE = __analysis_type.RandomVibe + + +class MinHoleDiameter: + """Constants for minimim hole diameter in the Export FEA Model request.""" + + def __init__(self, value, unit): + """Initialize the minimum hole diameter properties.""" + self.value = value + """value of the miminum diameter hole : float""" + self.unit = unit + """unit of the minimum diameter hole : string""" + + +class MaxEdgeLength: + """Constants for maximum edge length in the Export FEA Model request.""" + + def __init__(self, value, unit): + """Initialize the maximum edge length properties.""" + self.value = value + """value of the maximum edge length : float""" + self.unit = unit + """unit of the maximum edge length : string""" + + +class MaxMeshSize: + """Constants for maximum mesh size in the Export FEA Model request.""" + + def __init__(self, value, unit): + """Initialize the maximum mesh size properties.""" + self.value = value + """value of the maximum mesh size : float""" + self.unit = unit + """unit of the maximum mesh size : string""" + + +class VerticalMeshSize: + """Constants for vertical mesh size in the Export FEA Model request.""" + + def __init__(self, value, unit): + """Initialize the vertical mesh size properties.""" + self.value = value + """value of the vertical mesh size : float""" + self.unit = unit + """unit of the vertical mesh size : string""" diff --git a/tests/test_model.py b/tests/test_model.py index f8910d1c0..f1680d2be 100644 --- a/tests/test_model.py +++ b/tests/test_model.py @@ -7,8 +7,19 @@ import grpc import pytest -from ansys.sherlock.core.errors import SherlockExportAEDBError, SherlockModelServiceError +from ansys.sherlock.core.errors import ( + SherlockExportAEDBError, + SherlockExportFEAModelError, + SherlockModelServiceError, +) from ansys.sherlock.core.model import Model +from ansys.sherlock.core.types.model_types import ( + ExportFEAModelAnalysisType, + MaxEdgeLength, + MaxMeshSize, + MinHoleDiameter, + VerticalMeshSize, +) class TestModel(unittest.TestCase): @@ -363,6 +374,684 @@ def test_model_export_trace_model(self): except SherlockModelServiceError as e: pytest.fail(str(e)) + def test_export_FEA_model(self): + channel_param = "127.0.0.1:9090" + channel = grpc.insecure_channel(channel_param) + model = Model(channel) + + if platform.system() == "Windows": + temp_dir = os.environ.get("TEMP", "C:\\TEMP") + else: + temp_dir = os.environ.get("TEMP", "/tmp") + path = os.path.join(temp_dir, "export.wbjn") + + if model._is_connection_up(): + try: + model.export_FEA_model( + project="Tutorial Project", + cca_name="Invalid CCA", + export_file=path, + analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + drill_hole_parameters=[ + { + "drill_hole_modeling": "ENABLED", + "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), + "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + } + ], + detect_lead_modeling="ENABLED", + lead_model_parameters=[ + { + "lead_modeling": "ENABLED", + "lead_element_order": "First Order (Linear)", + "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), + "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "thicknessCount": 3, + "aspectRatio": 2, + } + ], + display_model=True, + clear_FEA_database=True, + use_FEA_model_id=True, + coordinate_units="mm", + ) + pytest.fail("No exception raised for invalid project name") + except Exception as e: + assert type(e) == SherlockExportFEAModelError + + try: + model.export_FEA_model( + project="", + cca_name="Main Board", + export_file=path, + analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + drill_hole_parameters=[ + { + "drill_hole_modeling": "ENABLED", + "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), + "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + } + ], + detect_lead_modeling="ENABLED", + lead_model_parameters=[ + { + "lead_modeling": "ENABLED", + "lead_element_order": "First Order (Linear)", + "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), + "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "thicknessCount": 3, + "aspectRatio": 2, + } + ], + display_model=True, + clear_FEA_database=True, + use_FEA_model_id=True, + coordinate_units="mm", + ) + pytest.fail("No exception raised for invalid project name") + except SherlockExportFEAModelError as e: + assert str(e) == "Export FEA model error: Project name is invalid." + + try: + model.export_FEA_model( + project="Tutorial Project", + cca_name="", + export_file=path, + analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + drill_hole_parameters=[ + { + "drill_hole_modeling": "ENABLED", + "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), + "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + } + ], + detect_lead_modeling="ENABLED", + lead_model_parameters=[ + { + "lead_modeling": "ENABLED", + "lead_element_order": "First Order (Linear)", + "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), + "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "thicknessCount": 3, + "aspectRatio": 2, + } + ], + display_model=True, + clear_FEA_database=True, + use_FEA_model_id=True, + coordinate_units="mm", + ) + pytest.fail("No exception raised for invalid project name") + except SherlockExportFEAModelError as e: + assert str(e) == "Export FEA model error: CCA name is invalid." + + try: + model.export_FEA_model( + project="Tutorial Project", + cca_name="Main Board", + export_file="", + analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + drill_hole_parameters=[ + { + "drill_hole_modeling": "ENABLED", + "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), + "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + } + ], + detect_lead_modeling="ENABLED", + lead_model_parameters=[ + { + "lead_modeling": "ENABLED", + "lead_element_order": "First Order (Linear)", + "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), + "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "thicknessCount": 3, + "aspectRatio": 2, + } + ], + display_model=True, + clear_FEA_database=True, + use_FEA_model_id=True, + coordinate_units="mm", + ) + pytest.fail("No exception raised for invalid project name") + except SherlockExportFEAModelError as e: + assert str(e) == "Export FEA model error: Export file path is invalid." + + try: + model.export_FEA_model( + project="Tutorial Project", + cca_name="Main Board", + export_file="test", + analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + drill_hole_parameters=[ + { + "drill_hole_modeling": "ENABLED", + "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), + "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + } + ], + detect_lead_modeling="ENABLED", + lead_model_parameters=[ + { + "lead_modeling": "ENABLED", + "lead_element_order": "First Order (Linear)", + "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), + "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "thicknessCount": 3, + "aspectRatio": 2, + } + ], + display_model=True, + clear_FEA_database=True, + use_FEA_model_id=True, + coordinate_units="mm", + ) + pytest.fail("No exception raised for invalid project name") + except SherlockExportFEAModelError as e: + assert str(e) == f'Export FEA model error: Export file directory "test" does not exist.' + + try: + model.export_FEA_model( + project="Tutorial Project", + cca_name="Main Board", + export_file=path, + analysis="", + drill_hole_parameters=[ + { + "drill_hole_modeling": "ENABLED", + "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), + "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + } + ], + detect_lead_modeling="ENABLED", + lead_model_parameters=[ + { + "lead_modeling": "ENABLED", + "lead_element_order": "First Order (Linear)", + "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), + "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "thicknessCount": 3, + "aspectRatio": 2, + } + ], + display_model=True, + clear_FEA_database=True, + use_FEA_model_id=True, + coordinate_units="mm", + ) + pytest.fail("No exception raised for invalid project name") + except SherlockExportFEAModelError as e: + assert str(e) == "Export FEA model error: Analysis for FEA model is invalid." + + try: + model.export_FEA_model( + project="Tutorial Project", + cca_name="Main Board", + export_file=path, + analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + drill_hole_parameters=[ + { + "drill_hole_modeling": "test", + "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), + "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + } + ], + detect_lead_modeling="ENABLED", + lead_model_parameters=[ + { + "lead_modeling": "ENABLED", + "lead_element_order": "First Order (Linear)", + "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), + "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "thicknessCount": 3, + "aspectRatio": 2, + } + ], + display_model=True, + clear_FEA_database=True, + use_FEA_model_id=True, + coordinate_units="mm", + ) + pytest.fail("No exception raised for invalid project name") + except SherlockExportFEAModelError as e: + assert str(e) == "Export FEA model error: Drill hole modeling status is invalid." + + try: + model.export_FEA_model( + project="Tutorial Project", + cca_name="Main Board", + export_file=path, + analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + drill_hole_parameters=[ + { + "drill_hole_modeling": "ENABLED", + "min_hole_diameter": 0, + "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + } + ], + detect_lead_modeling="ENABLED", + lead_model_parameters=[ + { + "lead_modeling": "ENABLED", + "lead_element_order": "First Order (Linear)", + "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), + "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "thicknessCount": 3, + "aspectRatio": 2, + } + ], + display_model=True, + clear_FEA_database=True, + use_FEA_model_id=True, + coordinate_units="mm", + ) + pytest.fail("No exception raised for invalid project name") + except SherlockExportFEAModelError as e: + assert str(e) == "Export FEA model error: Minimum hole diameter is invalid." + + try: + model.export_FEA_model( + project="Tutorial Project", + cca_name="Main Board", + export_file=path, + analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + drill_hole_parameters=[ + { + "drill_hole_modeling": "ENABLED", + "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), + "max_edge_length": 0, + } + ], + detect_lead_modeling="ENABLED", + lead_model_parameters=[ + { + "lead_modeling": "ENABLED", + "lead_element_order": "First Order (Linear)", + "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), + "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "thicknessCount": 3, + "aspectRatio": 2, + } + ], + display_model=True, + clear_FEA_database=True, + use_FEA_model_id=True, + coordinate_units="mm", + ) + pytest.fail("No exception raised for invalid project name") + except SherlockExportFEAModelError as e: + assert str(e) == "Export FEA model error: Maximum edge length is invalid." + + try: + model.export_FEA_model( + project="Tutorial Project", + cca_name="Main Board", + export_file=path, + analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + drill_hole_parameters=[ + { + "drill_hole_modeling": "ENABLED", + "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), + "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + } + ], + detect_lead_modeling="test", + lead_model_parameters=[ + { + "lead_modeling": "ENABLED", + "lead_element_order": "First Order (Linear)", + "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), + "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "thicknessCount": 3, + "aspectRatio": 2, + } + ], + display_model=True, + clear_FEA_database=True, + use_FEA_model_id=True, + coordinate_units="mm", + ) + pytest.fail("No exception raised for invalid project name") + except SherlockExportFEAModelError as e: + assert str(e) == "Export FEA model error: Detect lead modeling status is invalid." + + try: + model.export_FEA_model( + project="Tutorial Project", + cca_name="Main Board", + export_file=path, + analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + drill_hole_parameters=[ + { + "drill_hole_modeling": "ENABLED", + "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), + "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + } + ], + detect_lead_modeling="ENABLED", + lead_model_parameters=[ + { + "lead_modeling": "test", + "lead_element_order": "First Order (Linear)", + "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), + "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "thicknessCount": 3, + "aspectRatio": 2, + } + ], + display_model=True, + clear_FEA_database=True, + use_FEA_model_id=True, + coordinate_units="mm", + ) + pytest.fail("No exception raised for invalid project name") + except SherlockExportFEAModelError as e: + assert str(e) == "Export FEA model error: Lead modeling status is invalid." + + try: + model.export_FEA_model( + project="Tutorial Project", + cca_name="Main Board", + export_file=path, + analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + drill_hole_parameters=[ + { + "drill_hole_modeling": "ENABLED", + "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), + "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + } + ], + detect_lead_modeling="ENABLED", + lead_model_parameters=[ + { + "lead_modeling": "ENABLED", + "lead_element_order": "test", + "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), + "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "thicknessCount": 3, + "aspectRatio": 2, + } + ], + display_model=True, + clear_FEA_database=True, + use_FEA_model_id=True, + coordinate_units="mm", + ) + pytest.fail("No exception raised for invalid project name") + except SherlockExportFEAModelError as e: + assert str(e) == "Export FEA model error: Lead element order is invalid." + + try: + model.export_FEA_model( + project="Tutorial Project", + cca_name="Main Board", + export_file=path, + analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + drill_hole_parameters=[ + { + "drill_hole_modeling": "ENABLED", + "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), + "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + } + ], + detect_lead_modeling="ENABLED", + lead_model_parameters=[ + { + "lead_modeling": "ENABLED", + "lead_element_order": "First Order (Linear)", + "max_mesh_size": 0, + "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "thicknessCount": 3, + "aspectRatio": 2, + } + ], + display_model=True, + clear_FEA_database=True, + use_FEA_model_id=True, + coordinate_units="mm", + ) + pytest.fail("No exception raised for invalid project name") + except SherlockExportFEAModelError as e: + assert str(e) == "Export FEA model error: Maximum mesh size is invalid." + + try: + model.export_FEA_model( + project="Tutorial Project", + cca_name="Main Board", + export_file=path, + analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + drill_hole_parameters=[ + { + "drill_hole_modeling": "ENABLED", + "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), + "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + } + ], + detect_lead_modeling="ENABLED", + lead_model_parameters=[ + { + "lead_modeling": "ENABLED", + "lead_element_order": "First Order (Linear)", + "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), + "vertical_mesh_size": 0, + "thicknessCount": 3, + "aspectRatio": 2, + } + ], + display_model=True, + clear_FEA_database=True, + use_FEA_model_id=True, + coordinate_units="mm", + ) + pytest.fail("No exception raised for invalid project name") + except SherlockExportFEAModelError as e: + assert str(e) == "Export FEA model error: Vertical mesh size is invalid." + + try: + model.export_FEA_model( + project="Tutorial Project", + cca_name="Main Board", + export_file=path, + analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + drill_hole_parameters=[ + { + "drill_hole_modeling": "ENABLED", + "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), + "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + } + ], + detect_lead_modeling="ENABLED", + lead_model_parameters=[ + { + "lead_modeling": "ENABLED", + "lead_element_order": "First Order (Linear)", + "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), + "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "thicknessCount": "3", + "aspectRatio": 2, + } + ], + display_model=True, + clear_FEA_database=True, + use_FEA_model_id=True, + coordinate_units="mm", + ) + pytest.fail("No exception raised for invalid project name") + except SherlockExportFEAModelError as e: + assert str(e) == ( + "Export FEA model error: Invalid thickness count. Must be an " + "integer between 1 and 5, with a default value of 3." + ) + + try: + model.export_FEA_model( + project="Tutorial Project", + cca_name="Main Board", + export_file=path, + analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + drill_hole_parameters=[ + { + "drill_hole_modeling": "ENABLED", + "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), + "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + } + ], + detect_lead_modeling="ENABLED", + lead_model_parameters=[ + { + "lead_modeling": "ENABLED", + "lead_element_order": "First Order (Linear)", + "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), + "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "thicknessCount": 3, + "aspectRatio": "2", + } + ], + display_model=True, + clear_FEA_database=True, + use_FEA_model_id=True, + coordinate_units="mm", + ) + pytest.fail("No exception raised for invalid project name") + except SherlockExportFEAModelError as e: + assert str(e) == ( + "Export FEA model error: Invalid aspect ratio. Must be an integer " + "between 1 and 10, with a default value of 2." + ) + + try: + model.export_FEA_model( + project="Tutorial Project", + cca_name="Main Board", + export_file=path, + analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + drill_hole_parameters=[ + { + "drill_hole_modeling": "ENABLED", + "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), + "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + } + ], + detect_lead_modeling="ENABLED", + lead_model_parameters=[ + { + "lead_modeling": "ENABLED", + "lead_element_order": "First Order (Linear)", + "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), + "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "thicknessCount": 3, + "aspectRatio": 2, + } + ], + display_model="True", + clear_FEA_database=True, + use_FEA_model_id=True, + coordinate_units="mm", + ) + pytest.fail("No exception raised for invalid project name") + except SherlockExportFEAModelError as e: + assert str(e) == "Export FEA model error: display_model must be a boolean." + + try: + model.export_FEA_model( + project="Tutorial Project", + cca_name="Main Board", + export_file=path, + analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + drill_hole_parameters=[ + { + "drill_hole_modeling": "ENABLED", + "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), + "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + } + ], + detect_lead_modeling="ENABLED", + lead_model_parameters=[ + { + "lead_modeling": "ENABLED", + "lead_element_order": "First Order (Linear)", + "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), + "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "thicknessCount": 3, + "aspectRatio": 2, + } + ], + display_model=True, + clear_FEA_database="True", + use_FEA_model_id=True, + coordinate_units="mm", + ) + pytest.fail("No exception raised for invalid project name") + except SherlockExportFEAModelError as e: + assert str(e) == "Export FEA model error: clear_FEA_database must be a boolean." + + try: + model.export_FEA_model( + project="Tutorial Project", + cca_name="Main Board", + export_file=path, + analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + drill_hole_parameters=[ + { + "drill_hole_modeling": "ENABLED", + "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), + "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + } + ], + detect_lead_modeling="ENABLED", + lead_model_parameters=[ + { + "lead_modeling": "ENABLED", + "lead_element_order": "First Order (Linear)", + "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), + "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "thicknessCount": 3, + "aspectRatio": 2, + } + ], + display_model=True, + clear_FEA_database=True, + use_FEA_model_id="True", + coordinate_units="mm", + ) + pytest.fail("No exception raised for invalid project name") + except SherlockExportFEAModelError as e: + assert str(e) == "Export FEA model error: use_FEA_model_id must be a boolean." + + try: + model.export_FEA_model( + project="Tutorial Project", + cca_name="Main Board", + export_file=path, + analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + drill_hole_parameters=[ + { + "drill_hole_modeling": "ENABLED", + "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), + "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + } + ], + detect_lead_modeling="ENABLED", + lead_model_parameters=[ + { + "lead_modeling": "ENABLED", + "lead_element_order": "First Order (Linear)", + "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), + "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "thicknessCount": 3, + "aspectRatio": 2, + } + ], + display_model=True, + clear_FEA_database=True, + use_FEA_model_id=True, + coordinate_units=0, + ) + pytest.fail("No exception raised for invalid project name") + except SherlockExportFEAModelError as e: + assert str(e) == "Export FEA model error: coordinate_units must be a string." + if __name__ == "__main__": unittest.main() From ae4c4cd87f5a9fd9a3c212db1dc8af7e1f851d51 Mon Sep 17 00:00:00 2001 From: Nayane Fernandes <143632290+ansnfernand@users.noreply.github.com> Date: Tue, 16 Jul 2024 16:42:02 +0200 Subject: [PATCH 2/7] Fix code style --- src/ansys/sherlock/core/errors.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/ansys/sherlock/core/errors.py b/src/ansys/sherlock/core/errors.py index a28d59429..08457e3a4 100644 --- a/src/ansys/sherlock/core/errors.py +++ b/src/ansys/sherlock/core/errors.py @@ -1183,4 +1183,3 @@ def __init__(self, message): def __str__(self): """Format error message.""" return f"Export FEA model error: {self.message}" - From f4a5ea8f62a03af5429bc5eac8cb21904cb51bd2 Mon Sep 17 00:00:00 2001 From: Nayane Fernandes <143632290+ansnfernand@users.noreply.github.com> Date: Fri, 19 Jul 2024 10:52:32 +0200 Subject: [PATCH 3/7] Update after feedback --- doc/source/api/index.rst | 2 - doc/source/api/model_types.rst | 21 -- src/ansys/sherlock/core/model.py | 100 ++---- src/ansys/sherlock/core/types/common_types.py | 11 + src/ansys/sherlock/core/types/model_types.py | 65 ---- tests/test_model.py | 300 +++++------------- 6 files changed, 122 insertions(+), 377 deletions(-) delete mode 100644 doc/source/api/model_types.rst delete mode 100644 src/ansys/sherlock/core/types/model_types.py diff --git a/doc/source/api/index.rst b/doc/source/api/index.rst index 2f245ea14..a59bb8952 100644 --- a/doc/source/api/index.rst +++ b/doc/source/api/index.rst @@ -17,7 +17,6 @@ Use the search feature or click links to view API documentation. layer lifecycle model - model_types parts layer_types parts_types @@ -33,7 +32,6 @@ Use the search feature or click links to view API documentation. ansys.sherlock.core.layer ansys.sherlock.core.lifecycle ansys.sherlock.core.model - ansys.sherlock.core.types.model_types ansys.sherlock.core.parts ansys.sherlock.core.types.layer_types ansys.sherlock.core.types.parts_types diff --git a/doc/source/api/model_types.rst b/doc/source/api/model_types.rst deleted file mode 100644 index d0922323c..000000000 --- a/doc/source/api/model_types.rst +++ /dev/null @@ -1,21 +0,0 @@ -.. _ref_model_types: - -Model Types -=========== - -Classes used for the Model API. - -.. currentmodule:: ansys.sherlock.core.types.model_types - -.. autosummary:: - :toctree: _autosummary - - MaxEdgeLength - MaxMeshSize - MinHoleDiameter - VerticalMeshSize - -Constants ---------- -.. autoclass:: ExportFEAModelAnalysisType - :members: diff --git a/src/ansys/sherlock/core/model.py b/src/ansys/sherlock/core/model.py index f83eabd78..3949b3a5d 100644 --- a/src/ansys/sherlock/core/model.py +++ b/src/ansys/sherlock/core/model.py @@ -21,12 +21,7 @@ SherlockModelServiceError, ) from ansys.sherlock.core.grpc_stub import GrpcStub -from ansys.sherlock.core.types.model_types import ( - MaxEdgeLength, - MaxMeshSize, - MinHoleDiameter, - VerticalMeshSize, -) +from ansys.sherlock.core.types.common_types import Measurement class Model(GrpcStub): @@ -650,7 +645,7 @@ def export_FEA_model( project: str, cca_name: str, export_file: str, - analysis: int, + analysis: str, drill_hole_parameters: List[dict], detect_lead_modeling: str, lead_model_parameters: List[dict], @@ -670,8 +665,9 @@ def export_FEA_model( Name of the CCA. export_file : str Full path for saving exported files to. The file extension must be ``".wbjn"``. - analysis : ExportFEAModelAnalysisType - The type of analysis is being exported. + analysis : str + The type of analysis that is being exported. Valid values are ``NaturalFreq``, + ``HarmonicVibe``, ``ICTAnalysis``, ``MechanicalShock`` or ``RandomVibe``. drill_hole_parameters : list List of the drill hole parameters consisting of these properties: @@ -685,14 +681,14 @@ def export_FEA_model( The properties of the maximum edge length. detect_lead_modeling : str The status of the detect lead modeling feature. If enabled, automatically enable lead - modeling if any part has lead geometry defined. Valid values are ``ENABLED/enabled`` or - ``DISABLED/disabled``. + modeling if any part has lead geometry defined. Valid values are ``ENABLED`` or + ``DISABLED``. lead_model_parameters : list List of the lead model parameters consisting of these properties: - lead_modeling : str The status of the lead modeling feature. If enabled, automatically enable lead - modeling. Valid values are ``ENABLED/enabled`` or ``DISABLED/disabled``. + modeling. Valid values are ``ENABLED`` or ``DISABLED``. - lead_element_order : str The type of the element order. Valid values are ``First Order (Linear)``, ``Second Order (Quadratic)``, or ``Solid Shell``. @@ -726,24 +722,20 @@ def export_FEA_model( Examples -------- >>> from ansys.sherlock.core.launcher import launch_sherlock - >>> from ansys.sherlock.core.types.model_types import ( - ExportFEAModelAnalysisType, - MaxEdgeLength, - MaxMeshSize, - MinHoleDiameter, - VerticalMeshSize, + >>> from ansys.sherlock.core.types.common_types import ( + Measurement, ) >>> sherlock = launch_sherlock() >>> sherlock.model.export_FEA_model( project="Test Project", cca_name="Main Board", export_file="C:/Temp/export.wbjn", - analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + analysis="NaturalFreq", drill_hole_parameters=[ { "drill_hole_modeling": "ENABLED", - "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), - "max_edge_length": MaxEdgeLength(value=1.0, unit="mm") + "min_hole_diameter": Measurement(value=0.5, unit="mm"), + "max_edge_length": Measurement(value=1.0, unit="mm") } ], detect_lead_modeling="ENABLED", @@ -751,8 +743,8 @@ def export_FEA_model( { "lead_modeling": "ENABLED", "lead_element_order": "First Order (Linear)", - "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), - "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "max_mesh_size": Measurement(value=0.5, unit="mm"), + "vertical_mesh_size": Measurement(value=0.1, unit="mm"), "thicknessCount": 3, "aspectRatio": 2 } @@ -778,77 +770,51 @@ def export_FEA_model( message=f"Export file directory " f'"{export_file}" ' f"does not exist." ) - if not isinstance(analysis, int) or analysis == "": + if not isinstance(analysis, str) or analysis == "": raise SherlockExportFEAModelError(message=f"Analysis for FEA model is invalid.") for param in drill_hole_parameters: drill_hole_modeling = param.get("drill_hole_modeling") - if drill_hole_modeling not in ["ENABLED", "enabled", "DISABLED", "disabled"]: + if not isinstance(drill_hole_modeling, str): raise SherlockExportFEAModelError( - message="Drill hole modeling status " "is invalid." + message="Drill hole modeling status is " "invalid." ) min_hole_diameter = param.get("min_hole_diameter") - if not isinstance(min_hole_diameter, MinHoleDiameter): + if not isinstance(min_hole_diameter, Measurement): raise SherlockExportFEAModelError(message="Minimum hole diameter is invalid.") max_edge_length = param.get("max_edge_length") - if not isinstance(max_edge_length, MaxEdgeLength): + if not isinstance(max_edge_length, Measurement): raise SherlockExportFEAModelError(message="Maximum edge length is invalid.") - if detect_lead_modeling not in ["ENABLED", "enabled", "DISABLED", "disabled"]: + if not isinstance(detect_lead_modeling, str): raise SherlockExportFEAModelError(message="Detect lead modeling status is invalid.") for param in lead_model_parameters: lead_modeling = param.get("lead_modeling") - if lead_modeling not in ["ENABLED", "enabled", "DISABLED", "disabled"]: + if not isinstance(lead_modeling, str): raise SherlockExportFEAModelError(message="Lead modeling status is invalid.") lead_element_order = param.get("lead_element_order") - if lead_element_order not in [ - "First Order (Linear)", - "Second Order (Quadratic)", - "Solid Shell", - ]: + if not isinstance(lead_element_order, str): raise SherlockExportFEAModelError(message="Lead element order is invalid.") max_mesh_size = param.get("max_mesh_size") - if not isinstance(max_mesh_size, MaxMeshSize): + if not isinstance(max_mesh_size, Measurement): raise SherlockExportFEAModelError(message="Maximum mesh size is invalid.") vertical_mesh_size = param.get("vertical_mesh_size") - if not isinstance(vertical_mesh_size, VerticalMeshSize): + if not isinstance(vertical_mesh_size, Measurement): raise SherlockExportFEAModelError(message="Vertical mesh size is invalid.") - thickness_count = param.get("thicknessCount", 3) - if ( - not isinstance(thickness_count, int) - or thickness_count < 1 - or thickness_count > 5 - ): - raise SherlockExportFEAModelError( - message="Invalid thickness count. Must be an integer between 1 and 5, with " - "a default value of 3." - ) - - aspect_ratio = param.get("aspectRatio", 2) - if not isinstance(aspect_ratio, int) or aspect_ratio < 1 or aspect_ratio > 10: - raise SherlockExportFEAModelError( - message="Invalid aspect ratio. Must be an integer between 1 and 10, with " - "a default value of 2." - ) - - if not isinstance(display_model, bool): - raise SherlockExportFEAModelError(message="display_model must be a boolean.") - - if not isinstance(clear_FEA_database, bool): - raise SherlockExportFEAModelError(message="clear_FEA_database must be a boolean.") - - if not isinstance(use_FEA_model_id, bool): - raise SherlockExportFEAModelError(message="use_FEA_model_id must be a boolean.") + thickness_count = param.get("thicknessCount") + if not isinstance(thickness_count, int): + raise SherlockExportFEAModelError(message="Thickness count is invalid.") - if not isinstance(coordinate_units, str): - raise SherlockExportFEAModelError(message="coordinate_units must be a string.") + aspect_ratio = param.get("aspectRatio") + if not isinstance(aspect_ratio, int): + raise SherlockExportFEAModelError(message="Aspect ratio is invalid.") if not self._is_connection_up(): LOG.error("There is no connection to a gRPC service.") @@ -871,10 +837,10 @@ def export_FEA_model( export_request.drillHoleParam.maxEdgeLength.value = max_edge_length.value export_request.drillHoleParam.maxEdgeLength.unit = max_edge_length.unit - export_request.detectLeadModeling = detect_lead_modeling + export_request.detectLeadModeling = detect_lead_modeling.upper() for param in lead_model_parameters: - export_request.leadModelParam.leadModeling = param.get("lead_modeling") + export_request.leadModelParam.leadModeling = param.get("lead_modeling").upper() export_request.leadModelParam.leadElemOrder = param.get("lead_element_order") diff --git a/src/ansys/sherlock/core/types/common_types.py b/src/ansys/sherlock/core/types/common_types.py index e764abc99..20ead8c40 100644 --- a/src/ansys/sherlock/core/types/common_types.py +++ b/src/ansys/sherlock/core/types/common_types.py @@ -80,3 +80,14 @@ class TableDelimiter: """TAB""" SEMICOLON = SherlockCommonService_pb2.TableDelimiter.SEMICOLON """SEMICOLON""" + + +class Measurement: + """Contains the properties of the measurement.""" + + def __init__(self, value, unit): + """Initialize the measurement properties.""" + self.value = value + """value : float""" + self.unit = unit + """unit : string""" diff --git a/src/ansys/sherlock/core/types/model_types.py b/src/ansys/sherlock/core/types/model_types.py deleted file mode 100644 index 312e5a513..000000000 --- a/src/ansys/sherlock/core/types/model_types.py +++ /dev/null @@ -1,65 +0,0 @@ -# © 2024 ANSYS, Inc. All rights reserved. - -"""Module containing types for the Model Service.""" - -try: - import SherlockModelService_pb2 -except ModuleNotFoundError: - from ansys.api.sherlock.v0 import SherlockModelService_pb2 - -model_service = SherlockModelService_pb2 - - -class ExportFEAModelAnalysisType: - """Constants for type of analysis in the Export FEA Model request.""" - - __analysis_type = model_service.ExportFEAModelRequest.ExportAnalysis - NATURAL_FREQUENCY = __analysis_type.NaturalFreq - HARMONIC_VIBE = __analysis_type.HarmonicVibe - ICT = __analysis_type.ICTAnalysis - MECHANICAL_SHOCK = __analysis_type.MechanicalShock - RANDOM_VIBE = __analysis_type.RandomVibe - - -class MinHoleDiameter: - """Constants for minimim hole diameter in the Export FEA Model request.""" - - def __init__(self, value, unit): - """Initialize the minimum hole diameter properties.""" - self.value = value - """value of the miminum diameter hole : float""" - self.unit = unit - """unit of the minimum diameter hole : string""" - - -class MaxEdgeLength: - """Constants for maximum edge length in the Export FEA Model request.""" - - def __init__(self, value, unit): - """Initialize the maximum edge length properties.""" - self.value = value - """value of the maximum edge length : float""" - self.unit = unit - """unit of the maximum edge length : string""" - - -class MaxMeshSize: - """Constants for maximum mesh size in the Export FEA Model request.""" - - def __init__(self, value, unit): - """Initialize the maximum mesh size properties.""" - self.value = value - """value of the maximum mesh size : float""" - self.unit = unit - """unit of the maximum mesh size : string""" - - -class VerticalMeshSize: - """Constants for vertical mesh size in the Export FEA Model request.""" - - def __init__(self, value, unit): - """Initialize the vertical mesh size properties.""" - self.value = value - """value of the vertical mesh size : float""" - self.unit = unit - """unit of the vertical mesh size : string""" diff --git a/tests/test_model.py b/tests/test_model.py index f1680d2be..a10bdd8e2 100644 --- a/tests/test_model.py +++ b/tests/test_model.py @@ -13,13 +13,7 @@ SherlockModelServiceError, ) from ansys.sherlock.core.model import Model -from ansys.sherlock.core.types.model_types import ( - ExportFEAModelAnalysisType, - MaxEdgeLength, - MaxMeshSize, - MinHoleDiameter, - VerticalMeshSize, -) +from ansys.sherlock.core.types.common_types import Measurement class TestModel(unittest.TestCase): @@ -391,12 +385,12 @@ def test_export_FEA_model(self): project="Tutorial Project", cca_name="Invalid CCA", export_file=path, - analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + analysis="NaturalFreq", drill_hole_parameters=[ { "drill_hole_modeling": "ENABLED", - "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), - "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + "min_hole_diameter": Measurement(value=0.5, unit="mm"), + "max_edge_length": Measurement(value=1.0, unit="mm"), } ], detect_lead_modeling="ENABLED", @@ -404,8 +398,8 @@ def test_export_FEA_model(self): { "lead_modeling": "ENABLED", "lead_element_order": "First Order (Linear)", - "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), - "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "max_mesh_size": Measurement(value=0.5, unit="mm"), + "vertical_mesh_size": Measurement(value=0.1, unit="mm"), "thicknessCount": 3, "aspectRatio": 2, } @@ -424,12 +418,12 @@ def test_export_FEA_model(self): project="", cca_name="Main Board", export_file=path, - analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + analysis="NaturalFreq", drill_hole_parameters=[ { "drill_hole_modeling": "ENABLED", - "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), - "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + "min_hole_diameter": Measurement(value=0.5, unit="mm"), + "max_edge_length": Measurement(value=1.0, unit="mm"), } ], detect_lead_modeling="ENABLED", @@ -437,8 +431,8 @@ def test_export_FEA_model(self): { "lead_modeling": "ENABLED", "lead_element_order": "First Order (Linear)", - "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), - "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "max_mesh_size": Measurement(value=0.5, unit="mm"), + "vertical_mesh_size": Measurement(value=0.1, unit="mm"), "thicknessCount": 3, "aspectRatio": 2, } @@ -457,12 +451,12 @@ def test_export_FEA_model(self): project="Tutorial Project", cca_name="", export_file=path, - analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + analysis="NaturalFreq", drill_hole_parameters=[ { "drill_hole_modeling": "ENABLED", - "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), - "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + "min_hole_diameter": Measurement(value=0.5, unit="mm"), + "max_edge_length": Measurement(value=1.0, unit="mm"), } ], detect_lead_modeling="ENABLED", @@ -470,8 +464,8 @@ def test_export_FEA_model(self): { "lead_modeling": "ENABLED", "lead_element_order": "First Order (Linear)", - "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), - "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "max_mesh_size": Measurement(value=0.5, unit="mm"), + "vertical_mesh_size": Measurement(value=0.1, unit="mm"), "thicknessCount": 3, "aspectRatio": 2, } @@ -490,12 +484,12 @@ def test_export_FEA_model(self): project="Tutorial Project", cca_name="Main Board", export_file="", - analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + analysis="NaturalFreq", drill_hole_parameters=[ { "drill_hole_modeling": "ENABLED", - "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), - "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + "min_hole_diameter": Measurement(value=0.5, unit="mm"), + "max_edge_length": Measurement(value=1.0, unit="mm"), } ], detect_lead_modeling="ENABLED", @@ -503,8 +497,8 @@ def test_export_FEA_model(self): { "lead_modeling": "ENABLED", "lead_element_order": "First Order (Linear)", - "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), - "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "max_mesh_size": Measurement(value=0.5, unit="mm"), + "vertical_mesh_size": Measurement(value=0.1, unit="mm"), "thicknessCount": 3, "aspectRatio": 2, } @@ -523,12 +517,12 @@ def test_export_FEA_model(self): project="Tutorial Project", cca_name="Main Board", export_file="test", - analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + analysis="NaturalFreq", drill_hole_parameters=[ { "drill_hole_modeling": "ENABLED", - "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), - "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + "min_hole_diameter": Measurement(value=0.5, unit="mm"), + "max_edge_length": Measurement(value=1.0, unit="mm"), } ], detect_lead_modeling="ENABLED", @@ -536,8 +530,8 @@ def test_export_FEA_model(self): { "lead_modeling": "ENABLED", "lead_element_order": "First Order (Linear)", - "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), - "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "max_mesh_size": Measurement(value=0.5, unit="mm"), + "vertical_mesh_size": Measurement(value=0.1, unit="mm"), "thicknessCount": 3, "aspectRatio": 2, } @@ -560,8 +554,8 @@ def test_export_FEA_model(self): drill_hole_parameters=[ { "drill_hole_modeling": "ENABLED", - "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), - "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + "min_hole_diameter": Measurement(value=0.5, unit="mm"), + "max_edge_length": Measurement(value=1.0, unit="mm"), } ], detect_lead_modeling="ENABLED", @@ -569,8 +563,8 @@ def test_export_FEA_model(self): { "lead_modeling": "ENABLED", "lead_element_order": "First Order (Linear)", - "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), - "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "max_mesh_size": Measurement(value=0.5, unit="mm"), + "vertical_mesh_size": Measurement(value=0.1, unit="mm"), "thicknessCount": 3, "aspectRatio": 2, } @@ -589,12 +583,12 @@ def test_export_FEA_model(self): project="Tutorial Project", cca_name="Main Board", export_file=path, - analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + analysis="NaturalFreq", drill_hole_parameters=[ { "drill_hole_modeling": "test", - "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), - "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + "min_hole_diameter": Measurement(value=0.5, unit="mm"), + "max_edge_length": Measurement(value=1.0, unit="mm"), } ], detect_lead_modeling="ENABLED", @@ -602,8 +596,8 @@ def test_export_FEA_model(self): { "lead_modeling": "ENABLED", "lead_element_order": "First Order (Linear)", - "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), - "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "max_mesh_size": Measurement(value=0.5, unit="mm"), + "vertical_mesh_size": Measurement(value=0.1, unit="mm"), "thicknessCount": 3, "aspectRatio": 2, } @@ -622,12 +616,12 @@ def test_export_FEA_model(self): project="Tutorial Project", cca_name="Main Board", export_file=path, - analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + analysis="NaturalFreq", drill_hole_parameters=[ { "drill_hole_modeling": "ENABLED", "min_hole_diameter": 0, - "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + "max_edge_length": Measurement(value=1.0, unit="mm"), } ], detect_lead_modeling="ENABLED", @@ -635,8 +629,8 @@ def test_export_FEA_model(self): { "lead_modeling": "ENABLED", "lead_element_order": "First Order (Linear)", - "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), - "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "max_mesh_size": Measurement(value=0.5, unit="mm"), + "vertical_mesh_size": Measurement(value=0.1, unit="mm"), "thicknessCount": 3, "aspectRatio": 2, } @@ -655,11 +649,11 @@ def test_export_FEA_model(self): project="Tutorial Project", cca_name="Main Board", export_file=path, - analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + analysis="NaturalFreq", drill_hole_parameters=[ { "drill_hole_modeling": "ENABLED", - "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), + "min_hole_diameter": Measurement(value=0.5, unit="mm"), "max_edge_length": 0, } ], @@ -668,8 +662,8 @@ def test_export_FEA_model(self): { "lead_modeling": "ENABLED", "lead_element_order": "First Order (Linear)", - "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), - "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "max_mesh_size": Measurement(value=0.5, unit="mm"), + "vertical_mesh_size": Measurement(value=0.1, unit="mm"), "thicknessCount": 3, "aspectRatio": 2, } @@ -688,12 +682,12 @@ def test_export_FEA_model(self): project="Tutorial Project", cca_name="Main Board", export_file=path, - analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + analysis="NaturalFreq", drill_hole_parameters=[ { "drill_hole_modeling": "ENABLED", - "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), - "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + "min_hole_diameter": Measurement(value=0.5, unit="mm"), + "max_edge_length": Measurement(value=1.0, unit="mm"), } ], detect_lead_modeling="test", @@ -701,8 +695,8 @@ def test_export_FEA_model(self): { "lead_modeling": "ENABLED", "lead_element_order": "First Order (Linear)", - "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), - "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "max_mesh_size": Measurement(value=0.5, unit="mm"), + "vertical_mesh_size": Measurement(value=0.1, unit="mm"), "thicknessCount": 3, "aspectRatio": 2, } @@ -721,12 +715,12 @@ def test_export_FEA_model(self): project="Tutorial Project", cca_name="Main Board", export_file=path, - analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + analysis="NaturalFreq", drill_hole_parameters=[ { "drill_hole_modeling": "ENABLED", - "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), - "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + "min_hole_diameter": Measurement(value=0.5, unit="mm"), + "max_edge_length": Measurement(value=1.0, unit="mm"), } ], detect_lead_modeling="ENABLED", @@ -734,8 +728,8 @@ def test_export_FEA_model(self): { "lead_modeling": "test", "lead_element_order": "First Order (Linear)", - "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), - "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "max_mesh_size": Measurement(value=0.5, unit="mm"), + "vertical_mesh_size": Measurement(value=0.1, unit="mm"), "thicknessCount": 3, "aspectRatio": 2, } @@ -754,12 +748,12 @@ def test_export_FEA_model(self): project="Tutorial Project", cca_name="Main Board", export_file=path, - analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + analysis="NaturalFreq", drill_hole_parameters=[ { "drill_hole_modeling": "ENABLED", - "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), - "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + "min_hole_diameter": Measurement(value=0.5, unit="mm"), + "max_edge_length": Measurement(value=1.0, unit="mm"), } ], detect_lead_modeling="ENABLED", @@ -767,8 +761,8 @@ def test_export_FEA_model(self): { "lead_modeling": "ENABLED", "lead_element_order": "test", - "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), - "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "max_mesh_size": Measurement(value=0.5, unit="mm"), + "vertical_mesh_size": Measurement(value=0.1, unit="mm"), "thicknessCount": 3, "aspectRatio": 2, } @@ -787,12 +781,12 @@ def test_export_FEA_model(self): project="Tutorial Project", cca_name="Main Board", export_file=path, - analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + analysis="NaturalFreq", drill_hole_parameters=[ { "drill_hole_modeling": "ENABLED", - "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), - "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + "min_hole_diameter": Measurement(value=0.5, unit="mm"), + "max_edge_length": Measurement(value=1.0, unit="mm"), } ], detect_lead_modeling="ENABLED", @@ -801,7 +795,7 @@ def test_export_FEA_model(self): "lead_modeling": "ENABLED", "lead_element_order": "First Order (Linear)", "max_mesh_size": 0, - "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "vertical_mesh_size": Measurement(value=0.1, unit="mm"), "thicknessCount": 3, "aspectRatio": 2, } @@ -820,12 +814,12 @@ def test_export_FEA_model(self): project="Tutorial Project", cca_name="Main Board", export_file=path, - analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + analysis="NaturalFreq", drill_hole_parameters=[ { "drill_hole_modeling": "ENABLED", - "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), - "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + "min_hole_diameter": Measurement(value=0.5, unit="mm"), + "max_edge_length": Measurement(value=1.0, unit="mm"), } ], detect_lead_modeling="ENABLED", @@ -833,7 +827,7 @@ def test_export_FEA_model(self): { "lead_modeling": "ENABLED", "lead_element_order": "First Order (Linear)", - "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), + "max_mesh_size": Measurement(value=0.5, unit="mm"), "vertical_mesh_size": 0, "thicknessCount": 3, "aspectRatio": 2, @@ -853,12 +847,12 @@ def test_export_FEA_model(self): project="Tutorial Project", cca_name="Main Board", export_file=path, - analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + analysis="NaturalFreq", drill_hole_parameters=[ { "drill_hole_modeling": "ENABLED", - "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), - "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + "min_hole_diameter": Measurement(value=0.5, unit="mm"), + "max_edge_length": Measurement(value=1.0, unit="mm"), } ], detect_lead_modeling="ENABLED", @@ -866,8 +860,8 @@ def test_export_FEA_model(self): { "lead_modeling": "ENABLED", "lead_element_order": "First Order (Linear)", - "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), - "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "max_mesh_size": Measurement(value=0.5, unit="mm"), + "vertical_mesh_size": Measurement(value=0.1, unit="mm"), "thicknessCount": "3", "aspectRatio": 2, } @@ -879,22 +873,19 @@ def test_export_FEA_model(self): ) pytest.fail("No exception raised for invalid project name") except SherlockExportFEAModelError as e: - assert str(e) == ( - "Export FEA model error: Invalid thickness count. Must be an " - "integer between 1 and 5, with a default value of 3." - ) + assert str(e) == ("Export FEA model error: Thickness count is invalid.") try: model.export_FEA_model( project="Tutorial Project", cca_name="Main Board", export_file=path, - analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, + analysis="NaturalFreq", drill_hole_parameters=[ { "drill_hole_modeling": "ENABLED", - "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), - "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), + "min_hole_diameter": Measurement(value=0.5, unit="mm"), + "max_edge_length": Measurement(value=1.0, unit="mm"), } ], detect_lead_modeling="ENABLED", @@ -902,8 +893,8 @@ def test_export_FEA_model(self): { "lead_modeling": "ENABLED", "lead_element_order": "First Order (Linear)", - "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), - "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), + "max_mesh_size": Measurement(value=0.5, unit="mm"), + "vertical_mesh_size": Measurement(value=0.1, unit="mm"), "thicknessCount": 3, "aspectRatio": "2", } @@ -915,142 +906,7 @@ def test_export_FEA_model(self): ) pytest.fail("No exception raised for invalid project name") except SherlockExportFEAModelError as e: - assert str(e) == ( - "Export FEA model error: Invalid aspect ratio. Must be an integer " - "between 1 and 10, with a default value of 2." - ) - - try: - model.export_FEA_model( - project="Tutorial Project", - cca_name="Main Board", - export_file=path, - analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, - drill_hole_parameters=[ - { - "drill_hole_modeling": "ENABLED", - "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), - "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), - } - ], - detect_lead_modeling="ENABLED", - lead_model_parameters=[ - { - "lead_modeling": "ENABLED", - "lead_element_order": "First Order (Linear)", - "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), - "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), - "thicknessCount": 3, - "aspectRatio": 2, - } - ], - display_model="True", - clear_FEA_database=True, - use_FEA_model_id=True, - coordinate_units="mm", - ) - pytest.fail("No exception raised for invalid project name") - except SherlockExportFEAModelError as e: - assert str(e) == "Export FEA model error: display_model must be a boolean." - - try: - model.export_FEA_model( - project="Tutorial Project", - cca_name="Main Board", - export_file=path, - analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, - drill_hole_parameters=[ - { - "drill_hole_modeling": "ENABLED", - "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), - "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), - } - ], - detect_lead_modeling="ENABLED", - lead_model_parameters=[ - { - "lead_modeling": "ENABLED", - "lead_element_order": "First Order (Linear)", - "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), - "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), - "thicknessCount": 3, - "aspectRatio": 2, - } - ], - display_model=True, - clear_FEA_database="True", - use_FEA_model_id=True, - coordinate_units="mm", - ) - pytest.fail("No exception raised for invalid project name") - except SherlockExportFEAModelError as e: - assert str(e) == "Export FEA model error: clear_FEA_database must be a boolean." - - try: - model.export_FEA_model( - project="Tutorial Project", - cca_name="Main Board", - export_file=path, - analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, - drill_hole_parameters=[ - { - "drill_hole_modeling": "ENABLED", - "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), - "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), - } - ], - detect_lead_modeling="ENABLED", - lead_model_parameters=[ - { - "lead_modeling": "ENABLED", - "lead_element_order": "First Order (Linear)", - "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), - "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), - "thicknessCount": 3, - "aspectRatio": 2, - } - ], - display_model=True, - clear_FEA_database=True, - use_FEA_model_id="True", - coordinate_units="mm", - ) - pytest.fail("No exception raised for invalid project name") - except SherlockExportFEAModelError as e: - assert str(e) == "Export FEA model error: use_FEA_model_id must be a boolean." - - try: - model.export_FEA_model( - project="Tutorial Project", - cca_name="Main Board", - export_file=path, - analysis=ExportFEAModelAnalysisType.NATURAL_FREQUENCY, - drill_hole_parameters=[ - { - "drill_hole_modeling": "ENABLED", - "min_hole_diameter": MinHoleDiameter(value=0.5, unit="mm"), - "max_edge_length": MaxEdgeLength(value=1.0, unit="mm"), - } - ], - detect_lead_modeling="ENABLED", - lead_model_parameters=[ - { - "lead_modeling": "ENABLED", - "lead_element_order": "First Order (Linear)", - "max_mesh_size": MaxMeshSize(value=0.5, unit="mm"), - "vertical_mesh_size": VerticalMeshSize(value=0.1, unit="mm"), - "thicknessCount": 3, - "aspectRatio": 2, - } - ], - display_model=True, - clear_FEA_database=True, - use_FEA_model_id=True, - coordinate_units=0, - ) - pytest.fail("No exception raised for invalid project name") - except SherlockExportFEAModelError as e: - assert str(e) == "Export FEA model error: coordinate_units must be a string." + assert str(e) == ("Export FEA model error: Aspect ratio is invalid.") if __name__ == "__main__": From cba5a974347aa2492e780dd61faeffd2b87f9ce2 Mon Sep 17 00:00:00 2001 From: Nayane Fernandes <143632290+ansnfernand@users.noreply.github.com> Date: Fri, 19 Jul 2024 11:19:44 +0200 Subject: [PATCH 4/7] Update after feedback --- src/ansys/sherlock/core/model.py | 6 ++++-- tests/test_model.py | 12 ++++++------ 2 files changed, 10 insertions(+), 8 deletions(-) diff --git a/src/ansys/sherlock/core/model.py b/src/ansys/sherlock/core/model.py index 3949b3a5d..8f3f88822 100644 --- a/src/ansys/sherlock/core/model.py +++ b/src/ansys/sherlock/core/model.py @@ -777,7 +777,7 @@ def export_FEA_model( drill_hole_modeling = param.get("drill_hole_modeling") if not isinstance(drill_hole_modeling, str): raise SherlockExportFEAModelError( - message="Drill hole modeling status is " "invalid." + message="Drill hole modeling status is invalid." ) min_hole_diameter = param.get("min_hole_diameter") @@ -824,7 +824,9 @@ def export_FEA_model( export_request.project = project export_request.ccaName = cca_name export_request.exportFile = export_file - export_request.analysis = analysis + export_request.analysis = ( + SherlockModelService_pb2.ExportFEAModelRequest.ExportAnalysis.Value(analysis) + ) for param in drill_hole_parameters: export_request.drillHoleParam.drillHoleModeling = param.get("drill_hole_modeling") diff --git a/tests/test_model.py b/tests/test_model.py index a10bdd8e2..21cfacef3 100644 --- a/tests/test_model.py +++ b/tests/test_model.py @@ -586,7 +586,7 @@ def test_export_FEA_model(self): analysis="NaturalFreq", drill_hole_parameters=[ { - "drill_hole_modeling": "test", + "drill_hole_modeling": 0, "min_hole_diameter": Measurement(value=0.5, unit="mm"), "max_edge_length": Measurement(value=1.0, unit="mm"), } @@ -690,7 +690,7 @@ def test_export_FEA_model(self): "max_edge_length": Measurement(value=1.0, unit="mm"), } ], - detect_lead_modeling="test", + detect_lead_modeling=0, lead_model_parameters=[ { "lead_modeling": "ENABLED", @@ -726,7 +726,7 @@ def test_export_FEA_model(self): detect_lead_modeling="ENABLED", lead_model_parameters=[ { - "lead_modeling": "test", + "lead_modeling": 0, "lead_element_order": "First Order (Linear)", "max_mesh_size": Measurement(value=0.5, unit="mm"), "vertical_mesh_size": Measurement(value=0.1, unit="mm"), @@ -760,7 +760,7 @@ def test_export_FEA_model(self): lead_model_parameters=[ { "lead_modeling": "ENABLED", - "lead_element_order": "test", + "lead_element_order": 0, "max_mesh_size": Measurement(value=0.5, unit="mm"), "vertical_mesh_size": Measurement(value=0.1, unit="mm"), "thicknessCount": 3, @@ -873,7 +873,7 @@ def test_export_FEA_model(self): ) pytest.fail("No exception raised for invalid project name") except SherlockExportFEAModelError as e: - assert str(e) == ("Export FEA model error: Thickness count is invalid.") + assert str(e) == "Export FEA model error: Thickness count is invalid." try: model.export_FEA_model( @@ -906,7 +906,7 @@ def test_export_FEA_model(self): ) pytest.fail("No exception raised for invalid project name") except SherlockExportFEAModelError as e: - assert str(e) == ("Export FEA model error: Aspect ratio is invalid.") + assert str(e) == "Export FEA model error: Aspect ratio is invalid." if __name__ == "__main__": From 85e7fdda8c15e158c592117b7e40fd5669e7c92d Mon Sep 17 00:00:00 2001 From: Nayane Fernandes <143632290+ansnfernand@users.noreply.github.com> Date: Mon, 22 Jul 2024 16:44:27 +0200 Subject: [PATCH 5/7] Update after feedback --- src/ansys/sherlock/core/model.py | 28 --- tests/test_model.py | 297 ++++--------------------------- 2 files changed, 33 insertions(+), 292 deletions(-) diff --git a/src/ansys/sherlock/core/model.py b/src/ansys/sherlock/core/model.py index 8f3f88822..d959afb6d 100644 --- a/src/ansys/sherlock/core/model.py +++ b/src/ansys/sherlock/core/model.py @@ -770,16 +770,7 @@ def export_FEA_model( message=f"Export file directory " f'"{export_file}" ' f"does not exist." ) - if not isinstance(analysis, str) or analysis == "": - raise SherlockExportFEAModelError(message=f"Analysis for FEA model is invalid.") - for param in drill_hole_parameters: - drill_hole_modeling = param.get("drill_hole_modeling") - if not isinstance(drill_hole_modeling, str): - raise SherlockExportFEAModelError( - message="Drill hole modeling status is invalid." - ) - min_hole_diameter = param.get("min_hole_diameter") if not isinstance(min_hole_diameter, Measurement): raise SherlockExportFEAModelError(message="Minimum hole diameter is invalid.") @@ -788,18 +779,7 @@ def export_FEA_model( if not isinstance(max_edge_length, Measurement): raise SherlockExportFEAModelError(message="Maximum edge length is invalid.") - if not isinstance(detect_lead_modeling, str): - raise SherlockExportFEAModelError(message="Detect lead modeling status is invalid.") - for param in lead_model_parameters: - lead_modeling = param.get("lead_modeling") - if not isinstance(lead_modeling, str): - raise SherlockExportFEAModelError(message="Lead modeling status is invalid.") - - lead_element_order = param.get("lead_element_order") - if not isinstance(lead_element_order, str): - raise SherlockExportFEAModelError(message="Lead element order is invalid.") - max_mesh_size = param.get("max_mesh_size") if not isinstance(max_mesh_size, Measurement): raise SherlockExportFEAModelError(message="Maximum mesh size is invalid.") @@ -808,14 +788,6 @@ def export_FEA_model( if not isinstance(vertical_mesh_size, Measurement): raise SherlockExportFEAModelError(message="Vertical mesh size is invalid.") - thickness_count = param.get("thicknessCount") - if not isinstance(thickness_count, int): - raise SherlockExportFEAModelError(message="Thickness count is invalid.") - - aspect_ratio = param.get("aspectRatio") - if not isinstance(aspect_ratio, int): - raise SherlockExportFEAModelError(message="Aspect ratio is invalid.") - if not self._is_connection_up(): LOG.error("There is no connection to a gRPC service.") return diff --git a/tests/test_model.py b/tests/test_model.py index 21cfacef3..6ade2c4da 100644 --- a/tests/test_model.py +++ b/tests/test_model.py @@ -379,40 +379,6 @@ def test_export_FEA_model(self): temp_dir = os.environ.get("TEMP", "/tmp") path = os.path.join(temp_dir, "export.wbjn") - if model._is_connection_up(): - try: - model.export_FEA_model( - project="Tutorial Project", - cca_name="Invalid CCA", - export_file=path, - analysis="NaturalFreq", - drill_hole_parameters=[ - { - "drill_hole_modeling": "ENABLED", - "min_hole_diameter": Measurement(value=0.5, unit="mm"), - "max_edge_length": Measurement(value=1.0, unit="mm"), - } - ], - detect_lead_modeling="ENABLED", - lead_model_parameters=[ - { - "lead_modeling": "ENABLED", - "lead_element_order": "First Order (Linear)", - "max_mesh_size": Measurement(value=0.5, unit="mm"), - "vertical_mesh_size": Measurement(value=0.1, unit="mm"), - "thicknessCount": 3, - "aspectRatio": 2, - } - ], - display_model=True, - clear_FEA_database=True, - use_FEA_model_id=True, - coordinate_units="mm", - ) - pytest.fail("No exception raised for invalid project name") - except Exception as e: - assert type(e) == SherlockExportFEAModelError - try: model.export_FEA_model( project="", @@ -545,72 +511,6 @@ def test_export_FEA_model(self): except SherlockExportFEAModelError as e: assert str(e) == f'Export FEA model error: Export file directory "test" does not exist.' - try: - model.export_FEA_model( - project="Tutorial Project", - cca_name="Main Board", - export_file=path, - analysis="", - drill_hole_parameters=[ - { - "drill_hole_modeling": "ENABLED", - "min_hole_diameter": Measurement(value=0.5, unit="mm"), - "max_edge_length": Measurement(value=1.0, unit="mm"), - } - ], - detect_lead_modeling="ENABLED", - lead_model_parameters=[ - { - "lead_modeling": "ENABLED", - "lead_element_order": "First Order (Linear)", - "max_mesh_size": Measurement(value=0.5, unit="mm"), - "vertical_mesh_size": Measurement(value=0.1, unit="mm"), - "thicknessCount": 3, - "aspectRatio": 2, - } - ], - display_model=True, - clear_FEA_database=True, - use_FEA_model_id=True, - coordinate_units="mm", - ) - pytest.fail("No exception raised for invalid project name") - except SherlockExportFEAModelError as e: - assert str(e) == "Export FEA model error: Analysis for FEA model is invalid." - - try: - model.export_FEA_model( - project="Tutorial Project", - cca_name="Main Board", - export_file=path, - analysis="NaturalFreq", - drill_hole_parameters=[ - { - "drill_hole_modeling": 0, - "min_hole_diameter": Measurement(value=0.5, unit="mm"), - "max_edge_length": Measurement(value=1.0, unit="mm"), - } - ], - detect_lead_modeling="ENABLED", - lead_model_parameters=[ - { - "lead_modeling": "ENABLED", - "lead_element_order": "First Order (Linear)", - "max_mesh_size": Measurement(value=0.5, unit="mm"), - "vertical_mesh_size": Measurement(value=0.1, unit="mm"), - "thicknessCount": 3, - "aspectRatio": 2, - } - ], - display_model=True, - clear_FEA_database=True, - use_FEA_model_id=True, - coordinate_units="mm", - ) - pytest.fail("No exception raised for invalid project name") - except SherlockExportFEAModelError as e: - assert str(e) == "Export FEA model error: Drill hole modeling status is invalid." - try: model.export_FEA_model( project="Tutorial Project", @@ -677,105 +577,6 @@ def test_export_FEA_model(self): except SherlockExportFEAModelError as e: assert str(e) == "Export FEA model error: Maximum edge length is invalid." - try: - model.export_FEA_model( - project="Tutorial Project", - cca_name="Main Board", - export_file=path, - analysis="NaturalFreq", - drill_hole_parameters=[ - { - "drill_hole_modeling": "ENABLED", - "min_hole_diameter": Measurement(value=0.5, unit="mm"), - "max_edge_length": Measurement(value=1.0, unit="mm"), - } - ], - detect_lead_modeling=0, - lead_model_parameters=[ - { - "lead_modeling": "ENABLED", - "lead_element_order": "First Order (Linear)", - "max_mesh_size": Measurement(value=0.5, unit="mm"), - "vertical_mesh_size": Measurement(value=0.1, unit="mm"), - "thicknessCount": 3, - "aspectRatio": 2, - } - ], - display_model=True, - clear_FEA_database=True, - use_FEA_model_id=True, - coordinate_units="mm", - ) - pytest.fail("No exception raised for invalid project name") - except SherlockExportFEAModelError as e: - assert str(e) == "Export FEA model error: Detect lead modeling status is invalid." - - try: - model.export_FEA_model( - project="Tutorial Project", - cca_name="Main Board", - export_file=path, - analysis="NaturalFreq", - drill_hole_parameters=[ - { - "drill_hole_modeling": "ENABLED", - "min_hole_diameter": Measurement(value=0.5, unit="mm"), - "max_edge_length": Measurement(value=1.0, unit="mm"), - } - ], - detect_lead_modeling="ENABLED", - lead_model_parameters=[ - { - "lead_modeling": 0, - "lead_element_order": "First Order (Linear)", - "max_mesh_size": Measurement(value=0.5, unit="mm"), - "vertical_mesh_size": Measurement(value=0.1, unit="mm"), - "thicknessCount": 3, - "aspectRatio": 2, - } - ], - display_model=True, - clear_FEA_database=True, - use_FEA_model_id=True, - coordinate_units="mm", - ) - pytest.fail("No exception raised for invalid project name") - except SherlockExportFEAModelError as e: - assert str(e) == "Export FEA model error: Lead modeling status is invalid." - - try: - model.export_FEA_model( - project="Tutorial Project", - cca_name="Main Board", - export_file=path, - analysis="NaturalFreq", - drill_hole_parameters=[ - { - "drill_hole_modeling": "ENABLED", - "min_hole_diameter": Measurement(value=0.5, unit="mm"), - "max_edge_length": Measurement(value=1.0, unit="mm"), - } - ], - detect_lead_modeling="ENABLED", - lead_model_parameters=[ - { - "lead_modeling": "ENABLED", - "lead_element_order": 0, - "max_mesh_size": Measurement(value=0.5, unit="mm"), - "vertical_mesh_size": Measurement(value=0.1, unit="mm"), - "thicknessCount": 3, - "aspectRatio": 2, - } - ], - display_model=True, - clear_FEA_database=True, - use_FEA_model_id=True, - coordinate_units="mm", - ) - pytest.fail("No exception raised for invalid project name") - except SherlockExportFEAModelError as e: - assert str(e) == "Export FEA model error: Lead element order is invalid." - try: model.export_FEA_model( project="Tutorial Project", @@ -842,71 +643,39 @@ def test_export_FEA_model(self): except SherlockExportFEAModelError as e: assert str(e) == "Export FEA model error: Vertical mesh size is invalid." - try: - model.export_FEA_model( - project="Tutorial Project", - cca_name="Main Board", - export_file=path, - analysis="NaturalFreq", - drill_hole_parameters=[ - { - "drill_hole_modeling": "ENABLED", - "min_hole_diameter": Measurement(value=0.5, unit="mm"), - "max_edge_length": Measurement(value=1.0, unit="mm"), - } - ], - detect_lead_modeling="ENABLED", - lead_model_parameters=[ - { - "lead_modeling": "ENABLED", - "lead_element_order": "First Order (Linear)", - "max_mesh_size": Measurement(value=0.5, unit="mm"), - "vertical_mesh_size": Measurement(value=0.1, unit="mm"), - "thicknessCount": "3", - "aspectRatio": 2, - } - ], - display_model=True, - clear_FEA_database=True, - use_FEA_model_id=True, - coordinate_units="mm", - ) - pytest.fail("No exception raised for invalid project name") - except SherlockExportFEAModelError as e: - assert str(e) == "Export FEA model error: Thickness count is invalid." - - try: - model.export_FEA_model( - project="Tutorial Project", - cca_name="Main Board", - export_file=path, - analysis="NaturalFreq", - drill_hole_parameters=[ - { - "drill_hole_modeling": "ENABLED", - "min_hole_diameter": Measurement(value=0.5, unit="mm"), - "max_edge_length": Measurement(value=1.0, unit="mm"), - } - ], - detect_lead_modeling="ENABLED", - lead_model_parameters=[ - { - "lead_modeling": "ENABLED", - "lead_element_order": "First Order (Linear)", - "max_mesh_size": Measurement(value=0.5, unit="mm"), - "vertical_mesh_size": Measurement(value=0.1, unit="mm"), - "thicknessCount": 3, - "aspectRatio": "2", - } - ], - display_model=True, - clear_FEA_database=True, - use_FEA_model_id=True, - coordinate_units="mm", - ) - pytest.fail("No exception raised for invalid project name") - except SherlockExportFEAModelError as e: - assert str(e) == "Export FEA model error: Aspect ratio is invalid." + if model._is_connection_up(): + try: + model.export_FEA_model( + project="Tutorial Project", + cca_name="Invalid CCA", + export_file=path, + analysis="NaturalFreq", + drill_hole_parameters=[ + { + "drill_hole_modeling": "ENABLED", + "min_hole_diameter": Measurement(value=0.5, unit="mm"), + "max_edge_length": Measurement(value=1.0, unit="mm"), + } + ], + detect_lead_modeling="ENABLED", + lead_model_parameters=[ + { + "lead_modeling": "ENABLED", + "lead_element_order": "First Order (Linear)", + "max_mesh_size": Measurement(value=0.5, unit="mm"), + "vertical_mesh_size": Measurement(value=0.1, unit="mm"), + "thicknessCount": 3, + "aspectRatio": 2, + } + ], + display_model=True, + clear_FEA_database=True, + use_FEA_model_id=True, + coordinate_units="mm", + ) + pytest.fail("No exception raised for invalid project name") + except Exception as e: + assert type(e) == SherlockExportFEAModelError if __name__ == "__main__": From f48a7d244e778cc3f41b370a082ea3741493dda0 Mon Sep 17 00:00:00 2001 From: Nayane Fernandes <143632290+ansnfernand@users.noreply.github.com> Date: Tue, 23 Jul 2024 10:30:18 +0200 Subject: [PATCH 6/7] Update test_model.py --- tests/test_model.py | 39 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/tests/test_model.py b/tests/test_model.py index 6ade2c4da..9090876fa 100644 --- a/tests/test_model.py +++ b/tests/test_model.py @@ -677,6 +677,45 @@ def test_export_FEA_model(self): except Exception as e: assert type(e) == SherlockExportFEAModelError + try: + result = model.export_FEA_model( + project="Tutorial Project", + cca_name="Main Board", + export_file=path, + analysis="NaturalFreq", + drill_hole_parameters=[ + { + "drill_hole_modeling": "ENABLED", + "min_hole_diameter": Measurement(value=0.5, unit="mm"), + "max_edge_length": Measurement(value=1.0, unit="mm"), + } + ], + detect_lead_modeling="ENABLED", + lead_model_parameters=[ + { + "lead_modeling": "ENABLED", + "lead_element_order": "First Order (Linear)", + "max_mesh_size": Measurement(value=0.5, unit="mm"), + "vertical_mesh_size": Measurement(value=0.1, unit="mm"), + "thicknessCount": 3, + "aspectRatio": 2, + } + ], + display_model=False, + clear_FEA_database=False, + use_FEA_model_id=False, + coordinate_units="mm", + ) + assert result == 0 + + # Clean up file + if os.path.exists(path): + os.remove(path) + else: + pytest.fail("Failed to generate export file.") + except SherlockExportFEAModelError as e: + pytest.fail(str(e)) + if __name__ == "__main__": unittest.main() From 510587fe8bab654375d505629cbc2a7125e3dc25 Mon Sep 17 00:00:00 2001 From: Nayane Fernandes <143632290+ansnfernand@users.noreply.github.com> Date: Tue, 23 Jul 2024 16:32:26 +0200 Subject: [PATCH 7/7] Update test_model.py --- tests/test_model.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/tests/test_model.py b/tests/test_model.py index 9090876fa..9cd6ada6a 100644 --- a/tests/test_model.py +++ b/tests/test_model.py @@ -708,13 +708,12 @@ def test_export_FEA_model(self): ) assert result == 0 + except SherlockExportFEAModelError as e: + pytest.fail(str(e)) + finally: # Clean up file if os.path.exists(path): os.remove(path) - else: - pytest.fail("Failed to generate export file.") - except SherlockExportFEAModelError as e: - pytest.fail(str(e)) if __name__ == "__main__":