Create an AEDT-optiSLang project

[hui-zhou-a]

This example demonstrates how to create an optiSLang design and add an EDT node into a parametric system.

# Import required Python libraries
from pathlib import Path
from pydantic import BaseModel, Field

from ansys.optislang.core import node_types
from ansys.optislang.core import Optislang
from ansys.optislang.core import nodes
from ansys.optislang.core import project_parametric


# Prepare configuration classes. configuration classes are optional. They are created for ease of use purpose
class CfgCfgOptimizationParameter(BaseModel):
    domain_type: str | None = "real"
    kind: str | None = "continuous"
    lower_bound: float | None = -100
    upper_bound: float | None = 100


class CfgOptimizationParameter(BaseModel):
    name: str
    type: str | None = "deterministic"
    reference_value: float
    deterministic_property: CfgCfgOptimizationParameter
    const: bool = False
    unit: str = ""


class CfgResponse(BaseModel):
    name: str


class Parametric(BaseModel):
    optimization_parameters: list[CfgOptimizationParameter] | None = Field(
        default_factory=list
    )
    responses: list[CfgResponse] | None = Field(default_factory=list)

    def add_optimization_parameter(self, param: CfgOptimizationParameter):
        self.optimization_parameters.append(param)

    def add_response(self, param: CfgResponse):
        self.responses.append(param)


class OptislangForAEDT(BaseModel):
    input_data: str | Path | None = None
    output_data: str | Path | None = None
    batch: bool = False
    executable: str | Path | None = None
    aedt_executable: str | Path | None = None
    parametric: Parametric = Field(default_factory=Parametric)

    @classmethod
    def create(cls, **kwargs):
        return cls(**kwargs)


# This is the main method
def main(config: OptislangForAEDT):

    # Launch optiSLang
    osl = Optislang(
        executable=str(config.executable),
        batch=config.batch,
    )

    # If it is not in batch mode, a new optiSLang design should be created.
    if not config.batch:
        osl.application.new()

    # Get root system
    rs = osl.application.project.root_system

    # Create a parametric system
    parametric = rs.create_node(node_types.ParametricSystem)

    # Create a node in parametric system
    aedt_node = parametric.create_node(
        node_types.AEDT2, design_flow=nodes.DesignFlow.RECEIVE_SEND
    )

    # Get properties from the AEDT node
    pp = aedt_node.get_properties()

    path = pp["Path"]
    path["path"]["base_path_mode"]["value"] = "ABSOLUTE_PATH"
    path["path"]["split_path"]["head"] = str(Path(config.input_data).parent)
    path["path"]["split_path"]["tail"] = Path(config.input_data).name
    aedt_node.set_property(name="Path", value=path)

    settings = pp["Settings"]
    settings["sequence"][7]["Second"] = str(config.aedt_executable)
    aedt_node.set_property(name="Settings", value=settings)

    # Read AEDT project information
    aedt_node.load()

    # Create parameters
    pm = parametric.parameter_manager

    for i in config.parametric.optimization_parameters:

        location = {"dir": "input", "name": i.name}
        aedt_node.register_location_as_parameter(
            location=location,
        )

        pm.modify_parameter(
            project_parametric.OptimizationParameter(
                name=i.name,
                reference_value=i.reference_value,
                range=[
                    i.deterministic_property.lower_bound,
                    i.deterministic_property.upper_bound,
                ],
            )
        )

    # Create responses
    for i in config.parametric.responses:
        location = {"dir": "output", "name": i.name}
        aedt_node.register_location_as_response(location=location)

    # Save it as a new project
    osl.application.save_as(config.output_data)

    # Disconnect
    osl.dispose()


if __name__ == "__main__":
    cwd = Path(__file__).parent
    cfg = OptislangForAEDT.create(
        batch=False,
        # Path to AEDT project
        input_data=cwd / "example_files/aedt/tline_v3.aedt",
        # Path to save the optiSLang project
        output_data=cwd / "output/new.opf",
        # Path to optiSLang application
        executable=Path("C:/Program Files/ANSYS Inc/v261/optiSLang/optislang.exe"),
        # Path to AEDT application
        aedt_executable=Path("C:/Program Files/ANSYS Inc/v261/AnsysEM/ansysedt.exe"),
    )

    if not Path(cfg.input_data).exists():
        raise ValueError(f"{cfg.input_data} doesn't exist.")
    if not Path(cfg.output_data).parent.exists():
        raise ValueError(f"{cfg.output_data.parent} doesn't exist.")
    if not Path(cfg.aedt_executable).exists():
        raise ValueError(f"{cfg.aedt_executable} doesn't exist.")
    if not Path(cfg.executable).exists():
        raise ValueError(f"{cfg.executable} doesn't exist.")

    # Add variables and parameters
    variables = [["Thru_2x.length", 0, 0.03]]
    for i in variables:
        name, low, high = i
        cfg.parametric.add_optimization_parameter(
            CfgOptimizationParameter(
                name=name,
                type="deterministic",
                reference_value=0.01,
                deterministic_property=CfgCfgOptimizationParameter(
                    domain_type="real",
                    kind="continuous",
                    lower_bound=low,
                    upper_bound=high,
                ),
            )
        )
    # Add reports as responses
    reports = [
        "Thru_2x.eps_ref.(3e8/(2 * pi * Freq /cang_rad(S(Diff2,Diff1))*length))**2 []"
    ]
    for i in reports:
        cfg.parametric.add_response(CfgResponse(name=i))

    main(cfg)