Optimization#

Directory#

class OptimizationDirectory#

Provides a collection of methods related to optimizations.

This class is accessed through client.optimizations.

Example

import ansys.simai.core

simai = ansys.simai.core.from_config()
simai.optimizations.run_parametric(
    ...
)  # or simai.optimizations.run_non_parametric(...)

get(optimization_id: str) → Optimization#

Get a specific optimization object from the server.

Parameters:: optimization_id (str) – ID of the optimization.
Returns:: Optimization.
Return type:: Optimization

run_non_parametric(geometry: Geometry | str, bounding_boxes: List[List[float]], n_iters: int, symmetries: List[Literal['x', 'y', 'z', 'X', 'Y', 'Z']] | None = None, axial_symmetry: Literal['x', 'y', 'z'] | None = None, boundary_conditions: Dict[str, float] | None = None, minimize: List[str] | None = None, maximize: List[str] | None = None, max_displacement: List[float] | None = None, show_progress: bool = False) → OptimizationResult#

Run an optimization loop with server-side geometry generation using automorphism.

Parameters:

geometry (Geometry | str) – The base geometry on which to perform the automorphism. The optimization will run in the same workspace as the geometry.
bounding_boxes (List[List[float]]) – list of the bounds of the different boxes that will define the locations of the geometry to optimize. The format is [ [box1_xmin, box1_xmax, box1_ymin, box1_ymax, box1_zmin, box1_zmax], [box2_xmin, box2_xmax, box2_ymin, box2_ymax, box2_zmin, box2_zmax], … ]
n_iters (int) – Number of iterations of the optimization loop.
symmetries (List[Literal['x', 'y', 'z', 'X', 'Y', 'Z']] | None) –
Optional. The list of symmetry axes, axes being x, y, and z, defining a plane around which the geometry is mirrored.
- The planar symmetry is applied to all the bounding_boxes defined.
- symmetries and axial_symmetry are mutually exclusive parameters.
axial_symmetry (Literal['x', 'y', 'z'] | None) –
Optional. The axis, defined by a scalar, along which axial symmetry is applied. For the deformation to be axially symmetrical:
- The center of the bounding box must coincide with the targeted central axis.
- The mesh should be axially symmetrical in the bounding box.
- The axial_symmetry is applied to all the bounding_boxes defined.
- symmetries and axial_symmetry are mutually exclusive parameters.
boundary_conditions (Dict[str, float] | None) – Values of the boundary conditions to perform the optimization at. The values should map to existing boundary conditions in your project/workspace.
minimize (List[str] | None) – List of global coefficients to minimize. The global coefficients should map to existing coefficients in your project/workspace.
maximize (List[str] | None) – List of global coefficients to maximize. The global coefficients should map to existing coefficients in your project/workspace.
max_displacement (List[float] | None) – User-defined constraint on the maximum allowable deformation of the initial mesh in non-parametric optimization. It is specified as a list (max_displacement) matching the number of bounding boxes (box_bounds_list). Each value limits the displacement within the corresponding bounding box, using the same metric as the bounding box coordinates.
show_progress (bool) – Whether to print progress on stdout.

Example

import ansys.simai.core

simai = ansys.simai.core.from_config(workspace="optimization-workspace")
geometry = simai.geometries.list()[0]

simai.optimizations.run_non_parametric(
    geometry,
    bounding_boxes=[[0, 1, 0, 1, 0, 1]],
    boundary_conditions={"VelocityX": 10.5},
    symmetries=["y"],
    n_iters=10,
    minimize=["TotalForceX"],
    show_progress=True,
)

Run an optimization loop with client-side parametric geometry generation.

Parameters:

geometry_generation_fn (Callable[[...], Path | str | PathLike | Tuple[BinaryIO | RawIOBase | BufferedIOBase | Path | str | PathLike, str]]) – Function to call to generate a new geometry with the generated parameters. This parameter should return a NamedFile object.
geometry_parameters (Dict[str, Tuple[float, float]]) – Name of the geometry parameters and their bounds or possible values (choices).
boundary_conditions (Dict[str, float] | None) – Values of the boundary conditions to perform the optimization at. The values should map to existing boundary conditions in your project/workspace.
n_iters (int) – Number of iterations of the optimization loop.
minimize (List[str] | None) – List of global coefficients to minimize. The global coefficients should map to existing coefficients in your project/workspace.
maximize (List[str] | None) – List of global coefficients to maximize. The global coefficients should map to existing coefficients in your project/workspace.
outcome_constraints (List[str] | None) –
List of strings representing a linear inequality constraint on a global coefficient. The outcome constraint should be in the form gc >= x, where:
- gc is a valid global coefficient name.
- x is a float bound.
- The comparison operator is >= or <=.
show_progress (bool) – Whether to print progress on stdout.
workspace (Workspace | str | None) – Workspace to run the optimization in. If a workspace is not specified, the default is the configured workspace.

Returns:

List of dictionaries representing the result of each iteration. when constraints are specified, the list can be shorter than the number of iterations.

Return type:

List[Dict]

Warning

This is a long-running process and your computer must be powered on to generate the iterations. This method attempts to prevent your computer from sleeping, keeping your computer open during the process.

Example

import ansys.simai.core


# Function takes the parameters
def my_geometry_generation_function(param_a, param_b):
    # Implementation
    return "/path/to/generated/geometry.stl"


simai = ansys.simai.core.from_config(workspace="optimization-workspace")

simai.optimizations.run_parametric(
    geometry_generation_fn=my_geometry_generation_function,
    geometry_parameters={
        "param_a": {"bounds": (-12.5, 12.5)},
        "param_b": {"choices": (0, 1)},
    },
    minimize=["TotalForceX"],
    boundary_conditions={"VelocityX": 10.5},
    outcome_constraints=["TotalForceY <= 10"],
    n_iters=100,
)

Model#

class Optimization#

Provides the local representation of an optimization definition object.

reload() → None#

Refresh the object with its representation from the server.

wait(timeout: float | None = None) → bool#

Wait for all jobs concerning the object to either finish or fail.

Parameters:: timeout (float | None) – Maximum amount of time in seconds to wait. The default is None, it means that there is no maximum on the time to wait.
Returns:: True if the computation has finished, False if the operation timed out.
Return type:: bool

property failure_reason#

Optional message giving the causes for why the creation of the object failed.

See also

has_failed

property fields: dict#: Dictionary containing the raw object representation.

property has_failed#

Boolean indicating if the creation of the object failed.

See also

failure_reason
wait()
is_ready
is_pending

property id: str#: ID of the object on the server.

property is_pending#

Boolean indicating if the object is still in creation. The value becomes False once object creation is either successful or has failed.

See also

wait()
is_ready
has_failed

property is_ready#

Boolean indicating if the object has finished creating without error.

See also

wait()
is_pending
has_failed

class OptimizationResult#

Result for a non-parametric optimization.

list_geometries() → List[Geometry]#

List of geometries generated by the optimization.

list_objectives() → List[Dict]#

List of objectives generated by the optimization.

property optimization: Optimization#: Optimization object of the optimization run.