Update code from internal 0.5.0.dev2 development

src/ansys/meshing/prime/autogen/connectstructs.py

@@ -36,6 +36,277 @@ class MatchedMeshOption(enum.IntEnum):
     TRIMTWOSIDES = 4
     """Delete matched faces on both sides and merge matched nodes at middle locations (works only within a single part)."""
 
+class OverlapPairs(CoreObject):
+    """Provides ids of a pair of overlapping face zonelets.
+    """
+    _default_params = {}
+
+    def __initialize(
+            self,
+            zone_id0: int,
+            zone_id1: int):
+        self._zone_id0 = zone_id0
+        self._zone_id1 = zone_id1
+
+    def __init__(
+            self,
+            model: CommunicationManager=None,
+            zone_id0: int = None,
+            zone_id1: int = None,
+            json_data : dict = None,
+             **kwargs):
+        """Initializes the OverlapPairs.
+
+        Parameters
+        ----------
+        model: Model
+            Model to create a OverlapPairs object with default parameters.
+        zone_id0: int, optional
+            Id of one overlapping face zonelet.
+        zone_id1: int, optional
+            Id of other overlapping face zonelet.
+        json_data: dict, optional
+            JSON dictionary to create a OverlapPairs object with provided parameters.
+
+        Examples
+        --------
+        >>> overlap_pairs = prime.OverlapPairs(model = model)
+        """
+        if json_data:
+            self.__initialize(
+                json_data["zoneId0"] if "zoneId0" in json_data else None,
+                json_data["zoneId1"] if "zoneId1" in json_data else None)
+        else:
+            all_field_specified = all(arg is not None for arg in [zone_id0, zone_id1])
+            if all_field_specified:
+                self.__initialize(
+                    zone_id0,
+                    zone_id1)
+            else:
+                if model is None:
+                    raise ValueError("Invalid assignment. Either pass model or specify all properties")
+                else:
+                    param_json = model._communicator.initialize_params(model, "OverlapPairs")
+                    json_data = param_json["OverlapPairs"] if "OverlapPairs" in param_json else {}
+                    self.__initialize(
+                        zone_id0 if zone_id0 is not None else ( OverlapPairs._default_params["zone_id0"] if "zone_id0" in OverlapPairs._default_params else (json_data["zoneId0"] if "zoneId0" in json_data else None)),
+                        zone_id1 if zone_id1 is not None else ( OverlapPairs._default_params["zone_id1"] if "zone_id1" in OverlapPairs._default_params else (json_data["zoneId1"] if "zoneId1" in json_data else None)))
+        self._custom_params = kwargs
+        if model is not None:
+            [ model._logger.warning(f'Unsupported argument : {key}') for key in kwargs ]
+        [setattr(type(self), key, property(lambda self, key = key:  self._custom_params[key] if key in self._custom_params else None,
+        lambda self, value, key = key : self._custom_params.update({ key: value }))) for key in kwargs]
+        self._freeze()
+
+    @staticmethod
+    def set_default(
+            zone_id0: int = None,
+            zone_id1: int = None):
+        """Set the default values of OverlapPairs.
+
+        Parameters
+        ----------
+        zone_id0: int, optional
+            Id of one overlapping face zonelet.
+        zone_id1: int, optional
+            Id of other overlapping face zonelet.
+        """
+        args = locals()
+        [OverlapPairs._default_params.update({ key: value }) for key, value in args.items() if value is not None]
+
+    @staticmethod
+    def print_default():
+        """Print the default values of OverlapPairs.
+
+        Examples
+        --------
+        >>> OverlapPairs.print_default()
+        """
+        message = ""
+        message += ''.join(str(key) + ' : ' + str(value) + '\n' for key, value in OverlapPairs._default_params.items())
+        print(message)
+
+    def _jsonify(self) -> Dict[str, Any]:
+        json_data = {}
+        if self._zone_id0 is not None:
+            json_data["zoneId0"] = self._zone_id0
+        if self._zone_id1 is not None:
+            json_data["zoneId1"] = self._zone_id1
+        [ json_data.update({ utils.to_camel_case(key) : value }) for key, value in self._custom_params.items()]
+        return json_data
+
+    def __str__(self) -> str:
+        message = "zone_id0 :  %s\nzone_id1 :  %s" % (self._zone_id0, self._zone_id1)
+        message += ''.join('\n' + str(key) + ' : ' + str(value) for key, value in self._custom_params.items())
+        return message
+
+    @property
+    def zone_id0(self) -> int:
+        """Id of one overlapping face zonelet.
+        """
+        return self._zone_id0
+
+    @zone_id0.setter
+    def zone_id0(self, value: int):
+        self._zone_id0 = value
+
+    @property
+    def zone_id1(self) -> int:
+        """Id of other overlapping face zonelet.
+        """
+        return self._zone_id1
+
+    @zone_id1.setter
+    def zone_id1(self, value: int):
+        self._zone_id1 = value
+
+class OverlapSearchResults(CoreObject):
+    """Provides ids of a pair of overlapping face zonelets.
+    """
+    _default_params = {}
+
+    def __initialize(
+            self,
+            n_pairs: int,
+            overlap_pairs: List[OverlapPairs],
+            error_code: ErrorCode):
+        self._n_pairs = n_pairs
+        self._overlap_pairs = overlap_pairs
+        self._error_code = ErrorCode(error_code)
+
+    def __init__(
+            self,
+            model: CommunicationManager=None,
+            n_pairs: int = None,
+            overlap_pairs: List[OverlapPairs] = None,
+            error_code: ErrorCode = None,
+            json_data : dict = None,
+             **kwargs):
+        """Initializes the OverlapSearchResults.
+
+        Parameters
+        ----------
+        model: Model
+            Model to create a OverlapSearchResults object with default parameters.
+        n_pairs: int, optional
+            Number of pairs.
+        overlap_pairs: List[OverlapPairs], optional
+            Ids corresponding to pairs of overlapping face zonelets.
+        error_code: ErrorCode, optional
+            Error Code associated with failure of operation.
+        json_data: dict, optional
+            JSON dictionary to create a OverlapSearchResults object with provided parameters.
+
+        Examples
+        --------
+        >>> overlap_search_results = prime.OverlapSearchResults(model = model)
+        """
+        if json_data:
+            self.__initialize(
+                json_data["nPairs"] if "nPairs" in json_data else None,
+                [OverlapPairs(model = model, json_data = data) for data in json_data["overlapPairs"]] if "overlapPairs" in json_data else None,
+                ErrorCode(json_data["errorCode"] if "errorCode" in json_data else None))
+        else:
+            all_field_specified = all(arg is not None for arg in [n_pairs, overlap_pairs, error_code])
+            if all_field_specified:
+                self.__initialize(
+                    n_pairs,
+                    overlap_pairs,
+                    error_code)
+            else:
+                if model is None:
+                    raise ValueError("Invalid assignment. Either pass model or specify all properties")
+                else:
+                    param_json = model._communicator.initialize_params(model, "OverlapSearchResults")
+                    json_data = param_json["OverlapSearchResults"] if "OverlapSearchResults" in param_json else {}
+                    self.__initialize(
+                        n_pairs if n_pairs is not None else ( OverlapSearchResults._default_params["n_pairs"] if "n_pairs" in OverlapSearchResults._default_params else (json_data["nPairs"] if "nPairs" in json_data else None)),
+                        overlap_pairs if overlap_pairs is not None else ( OverlapSearchResults._default_params["overlap_pairs"] if "overlap_pairs" in OverlapSearchResults._default_params else [OverlapPairs(model = model, json_data = data) for data in (json_data["overlapPairs"] if "overlapPairs" in json_data else None)]),
+                        error_code if error_code is not None else ( OverlapSearchResults._default_params["error_code"] if "error_code" in OverlapSearchResults._default_params else ErrorCode(json_data["errorCode"] if "errorCode" in json_data else None)))
+        self._custom_params = kwargs
+        if model is not None:
+            [ model._logger.warning(f'Unsupported argument : {key}') for key in kwargs ]
+        [setattr(type(self), key, property(lambda self, key = key:  self._custom_params[key] if key in self._custom_params else None,
+        lambda self, value, key = key : self._custom_params.update({ key: value }))) for key in kwargs]
+        self._freeze()
+
+    @staticmethod
+    def set_default(
+            n_pairs: int = None,
+            overlap_pairs: List[OverlapPairs] = None,
+            error_code: ErrorCode = None):
+        """Set the default values of OverlapSearchResults.
+
+        Parameters
+        ----------
+        n_pairs: int, optional
+            Number of pairs.
+        overlap_pairs: List[OverlapPairs], optional
+            Ids corresponding to pairs of overlapping face zonelets.
+        error_code: ErrorCode, optional
+            Error Code associated with failure of operation.
+        """
+        args = locals()
+        [OverlapSearchResults._default_params.update({ key: value }) for key, value in args.items() if value is not None]
+
+    @staticmethod
+    def print_default():
+        """Print the default values of OverlapSearchResults.
+
+        Examples
+        --------
+        >>> OverlapSearchResults.print_default()
+        """
+        message = ""
+        message += ''.join(str(key) + ' : ' + str(value) + '\n' for key, value in OverlapSearchResults._default_params.items())
+        print(message)
+
+    def _jsonify(self) -> Dict[str, Any]:
+        json_data = {}
+        if self._n_pairs is not None:
+            json_data["nPairs"] = self._n_pairs
+        if self._overlap_pairs is not None:
+            json_data["overlapPairs"] = [data._jsonify() for data in self._overlap_pairs]
+        if self._error_code is not None:
+            json_data["errorCode"] = self._error_code
+        [ json_data.update({ utils.to_camel_case(key) : value }) for key, value in self._custom_params.items()]
+        return json_data
+
+    def __str__(self) -> str:
+        message = "n_pairs :  %s\noverlap_pairs :  %s\nerror_code :  %s" % (self._n_pairs, '[' + ''.join('\n' + str(data) for data in self._overlap_pairs) + ']', self._error_code)
+        message += ''.join('\n' + str(key) + ' : ' + str(value) for key, value in self._custom_params.items())
+        return message
+
+    @property
+    def n_pairs(self) -> int:
+        """Number of pairs.
+        """
+        return self._n_pairs
+
+    @n_pairs.setter
+    def n_pairs(self, value: int):
+        self._n_pairs = value
+
+    @property
+    def overlap_pairs(self) -> List[OverlapPairs]:
+        """Ids corresponding to pairs of overlapping face zonelets.
+        """
+        return self._overlap_pairs
+
+    @overlap_pairs.setter
+    def overlap_pairs(self, value: List[OverlapPairs]):
+        self._overlap_pairs = value
+
+    @property
+    def error_code(self) -> ErrorCode:
+        """Error Code associated with failure of operation.
+        """
+        return self._error_code
+
+    @error_code.setter
+    def error_code(self, value: ErrorCode):
+        self._error_code = value
+
 class ConnectResults(CoreObject):
     """Results associated with the connection operations.
     """

src/ansys/meshing/prime/autogen/fileiostructs.py

@@ -1265,6 +1265,7 @@ class ImportCadParams(CoreObject):
     def __initialize(
             self,
             append: bool,
+            ansys_release: str,
             cad_reader_route: CadReaderRoute,
             part_creation_type: PartCreationType,
             geometry_transfer: bool,
@@ -1274,6 +1275,7 @@ def __initialize(
             stitch_tolerance: float,
             cad_update_parameters: Dict[str, Union[str, int, float, bool]]):
         self._append = append
+        self._ansys_release = ansys_release
         self._cad_reader_route = CadReaderRoute(cad_reader_route)
         self._part_creation_type = PartCreationType(part_creation_type)
         self._geometry_transfer = geometry_transfer
@@ -1287,6 +1289,7 @@ def __init__(
             self,
             model: CommunicationManager=None,
             append: bool = None,
+            ansys_release: str = None,
             cad_reader_route: CadReaderRoute = None,
             part_creation_type: PartCreationType = None,
             geometry_transfer: bool = None,
@@ -1305,6 +1308,8 @@ def __init__(
             Model to create a ImportCadParams object with default parameters.
         append: bool, optional
             Append imported CAD into existing model when true.
+        ansys_release: str, optional
+            Configures the Ansys release to be used for loading CAD data through non Native route.
         cad_reader_route: CadReaderRoute, optional
             Specify the available CAD reader routes. The available CAD reader routes are ProgramControlled, Native, WorkBench, SpaceClaim.
         part_creation_type: PartCreationType, optional
@@ -1331,6 +1336,7 @@ def __init__(
         if json_data:
             self.__initialize(
                 json_data["append"] if "append" in json_data else None,
+                json_data["ansysRelease"] if "ansysRelease" in json_data else None,
                 CadReaderRoute(json_data["cadReaderRoute"] if "cadReaderRoute" in json_data else None),
                 PartCreationType(json_data["partCreationType"] if "partCreationType" in json_data else None),
                 json_data["geometryTransfer"] if "geometryTransfer" in json_data else None,
@@ -1340,10 +1346,11 @@ def __init__(
                 json_data["stitchTolerance"] if "stitchTolerance" in json_data else None,
                 json_data["cadUpdateParameters"] if "cadUpdateParameters" in json_data else None)
         else:
-            all_field_specified = all(arg is not None for arg in [append, cad_reader_route, part_creation_type, geometry_transfer, length_unit, refacet, cad_refaceting_params, stitch_tolerance, cad_update_parameters])
+            all_field_specified = all(arg is not None for arg in [append, ansys_release, cad_reader_route, part_creation_type, geometry_transfer, length_unit, refacet, cad_refaceting_params, stitch_tolerance, cad_update_parameters])
             if all_field_specified:
                 self.__initialize(
                     append,
+                    ansys_release,
                     cad_reader_route,
                     part_creation_type,
                     geometry_transfer,
@@ -1360,6 +1367,7 @@ def __init__(
                     json_data = param_json["ImportCadParams"] if "ImportCadParams" in param_json else {}
                     self.__initialize(
                         append if append is not None else ( ImportCadParams._default_params["append"] if "append" in ImportCadParams._default_params else (json_data["append"] if "append" in json_data else None)),
+                        ansys_release if ansys_release is not None else ( ImportCadParams._default_params["ansys_release"] if "ansys_release" in ImportCadParams._default_params else (json_data["ansysRelease"] if "ansysRelease" in json_data else None)),
                         cad_reader_route if cad_reader_route is not None else ( ImportCadParams._default_params["cad_reader_route"] if "cad_reader_route" in ImportCadParams._default_params else CadReaderRoute(json_data["cadReaderRoute"] if "cadReaderRoute" in json_data else None)),
                         part_creation_type if part_creation_type is not None else ( ImportCadParams._default_params["part_creation_type"] if "part_creation_type" in ImportCadParams._default_params else PartCreationType(json_data["partCreationType"] if "partCreationType" in json_data else None)),
                         geometry_transfer if geometry_transfer is not None else ( ImportCadParams._default_params["geometry_transfer"] if "geometry_transfer" in ImportCadParams._default_params else (json_data["geometryTransfer"] if "geometryTransfer" in json_data else None)),
@@ -1378,6 +1386,7 @@ def __init__(
     @staticmethod
     def set_default(
             append: bool = None,
+            ansys_release: str = None,
             cad_reader_route: CadReaderRoute = None,
             part_creation_type: PartCreationType = None,
             geometry_transfer: bool = None,
@@ -1392,6 +1401,8 @@ def set_default(
         ----------
         append: bool, optional
             Append imported CAD into existing model when true.
+        ansys_release: str, optional
+            Configures the Ansys release to be used for loading CAD data through non Native route.
         cad_reader_route: CadReaderRoute, optional
             Specify the available CAD reader routes. The available CAD reader routes are ProgramControlled, Native, WorkBench, SpaceClaim.
         part_creation_type: PartCreationType, optional
@@ -1428,6 +1439,8 @@ def _jsonify(self) -> Dict[str, Any]:
         json_data = {}
         if self._append is not None:
             json_data["append"] = self._append
+        if self._ansys_release is not None:
+            json_data["ansysRelease"] = self._ansys_release
         if self._cad_reader_route is not None:
             json_data["cadReaderRoute"] = self._cad_reader_route
         if self._part_creation_type is not None:
@@ -1448,7 +1461,7 @@ def _jsonify(self) -> Dict[str, Any]:
         return json_data
 
     def __str__(self) -> str:
-        message = "append :  %s\ncad_reader_route :  %s\npart_creation_type :  %s\ngeometry_transfer :  %s\nlength_unit :  %s\nrefacet :  %s\ncad_refaceting_params :  %s\nstitch_tolerance :  %s\ncad_update_parameters :  %s" % (self._append, self._cad_reader_route, self._part_creation_type, self._geometry_transfer, self._length_unit, self._refacet, '{ ' + str(self._cad_refaceting_params) + ' }', self._stitch_tolerance, self._cad_update_parameters)
+        message = "append :  %s\nansys_release :  %s\ncad_reader_route :  %s\npart_creation_type :  %s\ngeometry_transfer :  %s\nlength_unit :  %s\nrefacet :  %s\ncad_refaceting_params :  %s\nstitch_tolerance :  %s\ncad_update_parameters :  %s" % (self._append, self._ansys_release, self._cad_reader_route, self._part_creation_type, self._geometry_transfer, self._length_unit, self._refacet, '{ ' + str(self._cad_refaceting_params) + ' }', self._stitch_tolerance, self._cad_update_parameters)
         message += ''.join('\n' + str(key) + ' : ' + str(value) for key, value in self._custom_params.items())
         return message
 
@@ -1462,6 +1475,16 @@ def append(self) -> bool:
     def append(self, value: bool):
         self._append = value
 
+    @property
+    def ansys_release(self) -> str:
+        """Configures the Ansys release to be used for loading CAD data through non Native route.
+        """
+        return self._ansys_release
+
+    @ansys_release.setter
+    def ansys_release(self, value: str):
+        self._ansys_release = value
+
     @property
     def cad_reader_route(self) -> CadReaderRoute:
         """Specify the available CAD reader routes. The available CAD reader routes are ProgramControlled, Native, WorkBench, SpaceClaim.