simulation_configuration.py

# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
# SPDX-License-Identifier: MIT
#
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.

from collections import OrderedDict
import json
import os

from pyedb.dotnet.clr_module import Dictionary
from pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data import AdaptiveType
from pyedb.dotnet.edb_core.edb_data.sources import Source, SourceType
from pyedb.generic.constants import (
    BasisOrder,
    CutoutSubdesignType,
    RadiationBoxType,
    SolverType,
    SweepType,
    validate_enum_class_value,
)
from pyedb.generic.general_methods import generate_unique_name, pyedb_function_handler


class SimulationConfigurationBatch(object):
    """Contains all Cutout and Batch analysis settings.
    The class is part of `SimulationConfiguration` class as a property.


    """

    def __init__(self):
        self._signal_nets = []
        self._power_nets = []
        self._components = []
        self._cutout_subdesign_type = CutoutSubdesignType.Conformal  # Conformal
        self._cutout_subdesign_expansion = 0.001
        self._cutout_subdesign_round_corner = True
        self._use_default_cutout = False
        self._generate_excitations = True
        self._add_frequency_sweep = True
        self._include_only_selected_nets = False
        self._generate_solder_balls = True
        self._coax_solder_ball_diameter = []
        self._use_default_coax_port_radial_extension = True
        self._trim_reference_size = False
        self._output_aedb = None
        self._signal_layers_properties = {}
        self._coplanar_instances = []
        self._signal_layer_etching_instances = []
        self._etching_factor_instances = []
        self._use_dielectric_extent_multiple = True
        self._dielectric_extent = 0.001
        self._use_airbox_horizontal_multiple = True
        self._airbox_horizontal_extent = 0.1
        self._use_airbox_negative_vertical_extent_multiple = True
        self._airbox_negative_vertical_extent = 0.1
        self._use_airbox_positive_vertical_extent_multiple = True
        self._airbox_positive_vertical_extent = 0.1
        self._honor_user_dielectric = False
        self._truncate_airbox_at_ground = False
        self._use_radiation_boundary = True
        self._do_cutout_subdesign = True
        self._do_pin_group = True
        self._sources = []

    @property
    def coplanar_instances(self):  # pragma: no cover
        """Retrieve the list of component to be replaced by circuit ports (obsolete).

        Returns
        -------
            list[str]
            List of component name.
        """
        return self._coplanar_instances

    @coplanar_instances.setter
    def coplanar_instances(self, value):  # pragma: no cover
        if isinstance(value, list):
            self._coplanar_instances = value

    @property
    def signal_layer_etching_instances(self):  # pragma: no cover
        """Retrieve the list of layers which has layer etching activated.

        Returns
        -------
            list[str]
            List of layer name.
        """
        return self._signal_layer_etching_instances

    @signal_layer_etching_instances.setter
    def signal_layer_etching_instances(self, value):  # pragma: no cover
        if isinstance(value, list):
            self._signal_layer_etching_instances = value

    @property
    def etching_factor_instances(self):  # pragma: no cover
        """Retrieve the list of etching factor with associated layers.

        Returns
        -------
            list[str]
            list etching parameters with layer name.
        """
        return self._etching_factor_instances

    @etching_factor_instances.setter
    def etching_factor_instances(self, value):  # pragma: no cover
        if isinstance(value, list):
            self._etching_factor_instances = value

    @property
    def dielectric_extent(self):  # pragma: no cover
        """Retrieve the value of dielectric extent.

        Returns
        -------
        float
            Value of the dielectric extent. When absolute dimensions are used,
            the values are in meters.
        """
        return self._dielectric_extent

    @dielectric_extent.setter
    def dielectric_extent(self, value):  # pragma: no cover
        if isinstance(value, (int, float)):
            self._dielectric_extent = value

    @property
    def use_dielectric_extent_multiple(self):
        """Whether the multiple value of the dielectric extent is used.

        Returns
        -------
        bool
           ``True`` when the multiple value (extent factor) is used. ``False`` when
           absolute dimensions are used.
        """
        return self._use_dielectric_extent_multiple

    @use_dielectric_extent_multiple.setter
    def use_dielectric_extent_multiple(self, value):
        if isinstance(value, bool):
            self._use_dielectric_extent_multiple = value

    @property
    def airbox_horizontal_extent(self):  # pragma: no cover
        """Horizontal extent of the airbox for HFSS. When absolute dimensions are used,
        the values are in meters.

        Returns
        -------
            float
            Value of the air box horizontal extent.
        """
        return self._airbox_horizontal_extent

    @airbox_horizontal_extent.setter
    def airbox_horizontal_extent(self, value):  # pragma: no cover
        if isinstance(value, (int, float)):
            self._airbox_horizontal_extent = value

    @property
    def use_airbox_horizontal_extent_multiple(self):
        """Whether the multiple value is used for the horizontal extent of the air box.

        Returns
        -------
        bool
            ``True`` when the multiple value (extent factor) is used. ``False`` when
            absolute dimensions are used.

        """
        return self._use_airbox_horizontal_multiple

    @use_airbox_horizontal_extent_multiple.setter
    def use_airbox_horizontal_extent_multiple(self, value):
        if isinstance(value, bool):
            self._use_airbox_horizontal_multiple = value

    @property
    def airbox_negative_vertical_extent(self):  # pragma: no cover
        """Negative vertical extent of the airbox for HFSS. When absolute dimensions
        are used, the values are in meters.

        Returns
        -------
            float
            Value of the air box negative vertical extent.
        """
        return self._airbox_negative_vertical_extent

    @airbox_negative_vertical_extent.setter
    def airbox_negative_vertical_extent(self, value):  # pragma: no cover
        if isinstance(value, (int, float)):
            self._airbox_negative_vertical_extent = value

    @property
    def use_airbox_negative_vertical_extent_multiple(self):
        """Multiple value for the negative extent of the airbox.

        Returns
        -------
        bool
            ``True`` when the multiple value (extent factor) is used. ``False`` when
            absolute dimensions are used.

        """
        return self._use_airbox_negative_vertical_extent_multiple

    @use_airbox_negative_vertical_extent_multiple.setter
    def use_airbox_negative_vertical_extent_multiple(self, value):
        if isinstance(value, bool):
            self._use_airbox_negative_vertical_extent_multiple = value

    @property
    def airbox_positive_vertical_extent(self):  # pragma: no cover
        """Positive vertical extent of the airbox for HFSS. When absolute dimensions are
        used, the values are in meters.

        Returns
        -------
            float
            Value of the air box positive vertical extent.
        """
        return self._airbox_positive_vertical_extent

    @airbox_positive_vertical_extent.setter
    def airbox_positive_vertical_extent(self, value):  # pragma: no cover
        if isinstance(value, (int, float)):
            self._airbox_positive_vertical_extent = value

    @property
    def use_airbox_positive_vertical_extent_multiple(self):
        """Whether the multiple value for the positive extent of the airbox is used.

        Returns
        -------
        bool
            ``True`` when the multiple value (extent factor) is used. ``False`` when
            absolute dimensions are used.
        """
        return self._use_airbox_positive_vertical_extent_multiple

    @use_airbox_positive_vertical_extent_multiple.setter
    def use_airbox_positive_vertical_extent_multiple(self, value):
        if isinstance(value, bool):
            self._use_airbox_positive_vertical_extent_multiple = value

    @property
    def use_pyaedt_cutout(self):
        """Whether the default EDB cutout or a new PyAEDT cutout is used.

        Returns
        -------
        bool
        """
        return not self._use_default_cutout

    @use_pyaedt_cutout.setter
    def use_pyaedt_cutout(self, value):
        self._use_default_cutout = not value

    @property
    def use_default_cutout(self):  # pragma: no cover
        """Whether to use the default EDB cutout. The default is ``False``, in which case
        a new PyAEDT cutout is used.

        Returns
        -------
        bool
        """

        return self._use_default_cutout

    @use_default_cutout.setter
    def use_default_cutout(self, value):  # pragma: no cover
        self._use_default_cutout = value

    @property
    def do_pingroup(self):  # pragma: no cover
        """Do pingroup on multi-pin component. ``True`` all pins from the same net are grouped, ``False`` one port
        is created for each pin.

        Returns
        -------
        bool
        """
        return self._do_pin_group

    @do_pingroup.setter
    def do_pingroup(self, value):  # pragma: no cover
        self._do_pin_group = value

    @property
    def generate_solder_balls(self):  # pragma: no cover
        """Retrieve the boolean for applying solder balls.

        Returns
        -------
        bool
            ``True`` when applied ``False`` if not.
        """
        return self._generate_solder_balls

    @generate_solder_balls.setter
    def generate_solder_balls(self, value):
        if isinstance(value, bool):  # pragma: no cover
            self._generate_solder_balls = value

    @property
    def signal_nets(self):
        """Retrieve the list of signal net names.

        Returns
        -------
        List[str]
            List of signal net names.
        """

        return self._signal_nets

    @signal_nets.setter
    def signal_nets(self, value):
        if isinstance(value, list):  # pragma: no cover
            self._signal_nets = value

    @property
    def power_nets(self):
        """Retrieve the list of power and reference net names.

        Returns
        -------
        list[str]
            List of the net name.
        """
        return self._power_nets

    @power_nets.setter
    def power_nets(self, value):
        if isinstance(value, list):
            self._power_nets = value

    @property
    def components(self):
        """Retrieve the list component name to be included in the simulation.

        Returns
        -------
        list[str]
            List of the component name.
        """
        return self._components

    @components.setter
    def components(self, value):
        if isinstance(value, list):
            self._components = value

    @property
    def coax_solder_ball_diameter(self):  # pragma: no cover
        """Retrieve the list of solder balls diameter values when the auto evaluated one is overwritten.

        Returns
        -------
        list[float]
            List of the solder balls diameter.
        """
        return self._coax_solder_ball_diameter

    @coax_solder_ball_diameter.setter
    def coax_solder_ball_diameter(self, value):  # pragma: no cover
        if isinstance(value, list):
            self._coax_solder_ball_diameter = value

    @property
    def use_default_coax_port_radial_extension(self):
        """Retrieve the boolean for using the default coaxial port extension value.

        Returns
        -------
        bool
            ``True`` when the default value is used ``False`` if not.
        """
        return self._use_default_coax_port_radial_extension

    @use_default_coax_port_radial_extension.setter
    def use_default_coax_port_radial_extension(self, value):  # pragma: no cover
        if isinstance(value, bool):
            self._use_default_coax_port_radial_extension = value

    @property
    def trim_reference_size(self):
        """Retrieve the trim reference size when used.

        Returns
        -------
        float
            The size value.
        """
        return self._trim_reference_size

    @trim_reference_size.setter
    def trim_reference_size(self, value):  # pragma: no cover
        if isinstance(value, bool):
            self._trim_reference_size = value

    @property
    def do_cutout_subdesign(self):
        """Retrieve boolean to perform the cutout during the project build.

        Returns
        -------
            bool
            ``True`` when clipping the design is applied ``False`` is not.
        """
        return self._do_cutout_subdesign

    @do_cutout_subdesign.setter
    def do_cutout_subdesign(self, value):  # pragma: no cover
        if isinstance(value, bool):
            self._do_cutout_subdesign = value

    @property
    def cutout_subdesign_type(self):
        """Retrieve the CutoutSubdesignType selection for clipping the design.

        Returns
        -------
        CutoutSubdesignType object
        """
        return self._cutout_subdesign_type

    @cutout_subdesign_type.setter
    def cutout_subdesign_type(self, value):  # pragma: no cover
        if validate_enum_class_value(CutoutSubdesignType, value):
            self._cutout_subdesign_type = value

    @property
    def cutout_subdesign_expansion(self):
        """Retrieve expansion factor used for clipping the design.

        Returns
        -------
        float
            The value used as a ratio.
        """

        return self._cutout_subdesign_expansion

    @cutout_subdesign_expansion.setter
    def cutout_subdesign_expansion(self, value):  # pragma: no cover
        self._cutout_subdesign_expansion = value

    @property
    def cutout_subdesign_round_corner(self):
        """Retrieve boolean to perform the design clipping using round corner for the extent generation.

        Returns
        -------
        bool
            ``True`` when using round corner, ``False`` if not.
        """

        return self._cutout_subdesign_round_corner

    @cutout_subdesign_round_corner.setter
    def cutout_subdesign_round_corner(self, value):  # pragma: no cover
        if isinstance(value, bool):
            self._cutout_subdesign_round_corner = value

    @property
    def output_aedb(self):  # pragma: no cover
        """Retrieve the path for the output aedb folder. When provided will copy the initial aedb to the specified
        path. This is used especially to preserve the initial project when several files have to be build based on
        the last one. When the path is None, the initial project will be overwritten. So when cutout is applied mand
        you want to preserve the project make sure you provide the full path for the new aedb folder.

        Returns
        -------
        str
            Absolute path for the created aedb folder.
        """
        return self._output_aedb

    @output_aedb.setter
    def output_aedb(self, value):  # pragma: no cover
        if isinstance(value, str):
            self._output_aedb = value

    @property
    def sources(self):  # pragma: no cover
        """Retrieve the source list.

        Returns
        -------
        :class:`dotnet.edb_core.edb_data.sources.Source`
        """
        return self._sources

    @sources.setter
    def sources(self, value):  # pragma: no cover
        if isinstance(value, Source):
            value = [value]
        if isinstance(value, list):
            if len([src for src in value if isinstance(src, Source)]) == len(value):
                self._sources = value

    @pyedb_function_handler()
    def add_source(self, source=None):  # pragma: no cover
        """Add a new source to configuration.

        Parameters
        ----------
        source : :class:`pyedb.dotnet.edb_core.edb_data.sources.Source`

        """
        if isinstance(source, Source):
            self._sources.append(source)

    @property
    def honor_user_dielectric(self):  # pragma: no cover
        """Retrieve the boolean to activate the feature "'Honor user dielectric'".

        Returns
        -------
        bool
            ``True`` activated, ``False`` deactivated.
        """
        return self._honor_user_dielectric

    @honor_user_dielectric.setter
    def honor_user_dielectric(self, value):  # pragma: no cover
        if isinstance(value, bool):
            self._honor_user_dielectric = value

    @property
    def truncate_airbox_at_ground(self):  # pragma: no cover
        """Retrieve the boolean to truncate hfss air box at ground.

        Returns
        -------
        bool
            ``True`` activated, ``False`` deactivated.
        """
        return self._truncate_airbox_at_ground

    @truncate_airbox_at_ground.setter
    def truncate_airbox_at_ground(self, value):  # pragma: no cover
        if isinstance(value, bool):
            self._truncate_airbox_at_ground = value

    @property
    def use_radiation_boundary(self):  # pragma: no cover
        """Retrieve the boolean to use radiation boundary with HFSS.

        Returns
        -------
        bool
            ``True`` activated, ``False`` deactivated.
        """
        return self._use_radiation_boundary

    @use_radiation_boundary.setter
    def use_radiation_boundary(self, value):  # pragma: no cover
        if isinstance(value, bool):
            self._use_radiation_boundary = value

    @property
    def signal_layers_properties(self):  # pragma: no cover
        """Retrieve the list of layers to have properties changes.

        Returns
        -------
        list[str]
            List of layer name.
        """
        return self._signal_layers_properties

    @signal_layers_properties.setter
    def signal_layers_properties(self, value):  # pragma: no cover
        if isinstance(value, dict):
            self._signal_layers_properties = value

    @property
    def generate_excitations(self):
        """Activate ports and sources for DC generation when build project with the class.

        Returns
        -------
        bool
            ``True`` ports are created, ``False`` skip port generation. Default value is ``True``.

        """
        return self._generate_excitations

    @generate_excitations.setter
    def generate_excitations(self, value):
        if isinstance(value, bool):
            self._generate_excitations = value

    @property
    def add_frequency_sweep(self):
        """Activate the frequency sweep creation when build project with the class.

        Returns
        -------
        bool
            ``True`` frequency sweep is created, ``False`` skip sweep adding. Default value is ``True``.
        """
        return self._add_frequency_sweep

    @add_frequency_sweep.setter
    def add_frequency_sweep(self, value):
        if isinstance(value, bool):
            self._add_frequency_sweep = value

    @property
    def include_only_selected_nets(self):
        """Include only net selection in the project. It is only used when ``do_cutout`` is set to ``False``.
        Will also be ignored if signal_nets and power_nets are ``None``, resulting project will have all nets included.

        Returns
        -------
        bool
            ``True`` or ``False``. Default value is ``False``.

        """
        return self._include_only_selected_nets

    @include_only_selected_nets.setter
    def include_only_selected_nets(self, value):
        if isinstance(value, bool):
            self._include_only_selected_nets = value


class SimulationConfigurationDc(object):
    """Contains all DC analysis settings.
    The class is part of `SimulationConfiguration` class as a property.

    """

    def __init__(self):
        self._dc_compute_inductance = False
        self._dc_contact_radius = "100um"
        self._dc_slide_position = 1
        self._dc_use_dc_custom_settings = False
        self._dc_plot_jv = True
        self._dc_min_plane_area_to_mesh = "8mil2"
        self._dc_min_void_area_to_mesh = "0.734mil2"
        self._dc_error_energy = 0.02
        self._dc_max_init_mesh_edge_length = "5.0mm"
        self._dc_max_num_pass = 5
        self._dc_min_num_pass = 1
        self._dc_mesh_bondwires = True
        self._dc_num_bondwire_sides = 8
        self._dc_mesh_vias = True
        self._dc_num_via_sides = 8
        self._dc_percent_local_refinement = 0.2
        self._dc_perform_adaptive_refinement = True
        self._dc_refine_bondwires = True
        self._dc_refine_vias = True
        self._dc_report_config_file = ""
        self._dc_report_show_Active_devices = True
        self._dc_export_thermal_data = True
        self._dc_full_report_path = ""
        self._dc_icepak_temp_file = ""
        self._dc_import_thermal_data = False
        self._dc_per_pin_res_path = ""
        self._dc_per_pin_use_pin_format = True
        self._dc_use_loop_res_for_per_pin = True
        self._dc_via_report_path = ""
        self._dc_source_terms_to_ground = Dictionary[str, int]()

    @property
    def dc_min_plane_area_to_mesh(self):  # pragma: no cover
        """Retrieve the value of the minimum plane area to be meshed by Siwave for DC solution.

        Returns
        -------
        float
            The value of the minimum plane area.
        """
        return self._dc_min_plane_area_to_mesh

    @dc_min_plane_area_to_mesh.setter
    def dc_min_plane_area_to_mesh(self, value):  # pragma: no cover
        if isinstance(value, str):
            self._dc_min_plane_area_to_mesh = value

    @property
    def dc_compute_inductance(self):
        """Return the boolean for computing the inductance with SIwave DC solver.

        Returns
        -------
        bool
            ``True`` activate ``False`` deactivated.
        """
        return self._dc_compute_inductance

    @dc_compute_inductance.setter
    def dc_compute_inductance(self, value):
        if isinstance(value, bool):
            self._dc_compute_inductance = value

    @property
    def dc_contact_radius(self):
        """Retrieve the value for SIwave DC contact radius.

        Returns
        -------
        str
            The contact radius value.

        """
        return self._dc_contact_radius

    @dc_contact_radius.setter
    def dc_contact_radius(self, value):
        if isinstance(value, str):
            self._dc_contact_radius = value

    @dc_compute_inductance.setter
    def dc_compute_inductance(self, value):
        if isinstance(value, str):
            self._dc_contact_radius = value

    @property
    def dc_slide_position(self):
        """Retrieve the SIwave DC slide position value.

        Returns
        -------
        int
            The position value, 0 Optimum speed, 1 balanced, 2 optimum accuracy.
        """
        return self._dc_slide_position

    @dc_slide_position.setter
    def dc_slide_position(self, value):
        if isinstance(value, int):
            self._dc_slide_position = value

    @property
    def dc_use_dc_custom_settings(self):
        """Retrieve the value for using DC custom settings.

        Returns
        -------
        bool
            ``True`` when activated, ``False`` deactivated.

        """
        return self._dc_use_dc_custom_settings

    @dc_use_dc_custom_settings.setter
    def dc_use_dc_custom_settings(self, value):
        if isinstance(value, bool):
            self._dc_use_dc_custom_settings = value

    @property
    def dc_plot_jv(self):
        """Retrieve the value for computing current density and voltage distribution.

        Returns
        -------
        bool
            ``True`` when activated, ``False`` deactivated. Default value True

        """
        return self._dc_plot_jv

    @dc_plot_jv.setter
    def dc_plot_jv(self, value):
        if isinstance(value, bool):
            self._dc_plot_jv = value

    @property
    def dc_min_void_area_to_mesh(self):
        """Retrieve the value for the minimum void surface to mesh.

        Returns
        -------
        str
            The area value.

        """
        return self._dc_min_void_area_to_mesh

    @dc_min_void_area_to_mesh.setter
    def dc_min_void_area_to_mesh(self, value):
        if isinstance(value, str):
            self._dc_min_void_area_to_mesh = value

    @property
    def dc_error_energy(self):
        """Retrieve the value for the DC error energy.

        Returns
        -------
        float
            The error energy value, 0.2 as default.

        """
        return self._dc_error_energy

    @dc_error_energy.setter
    def dc_error_energy(self, value):
        if isinstance(value, (int, float)):
            self._dc_error_energy = value

    @property
    def dc_max_init_mesh_edge_length(self):
        """Retrieve the maximum initial mesh edge value.

        Returns
        -------
        str
            maximum mesh length.

        """
        return self._dc_max_init_mesh_edge_length

    @dc_max_init_mesh_edge_length.setter
    def dc_max_init_mesh_edge_length(self, value):
        if isinstance(value, str):
            self._dc_max_init_mesh_edge_length = value

    @property
    def dc_max_num_pass(self):
        """Retrieve the maximum number of adaptive passes.

        Returns
        -------
        int
            number of passes.
        """
        return self._dc_max_num_pass

    @dc_max_num_pass.setter
    def dc_max_num_pass(self, value):
        if isinstance(value, int):
            self._dc_max_num_pass = value

    @property
    def dc_min_num_pass(self):
        """Retrieve the minimum number of adaptive passes.

        Returns
        -------
        int
            number of passes.
        """
        return self._dc_min_num_pass

    @dc_min_num_pass.setter
    def dc_min_num_pass(self, value):
        if isinstance(value, int):
            self._dc_min_num_pass = value

    @property
    def dc_mesh_bondwires(self):
        """Retrieve the value for meshing bondwires.

        Returns
        -------
        bool
            ``True`` when activated, ``False`` deactivated.

        """
        return self._dc_mesh_bondwires

    @dc_mesh_bondwires.setter
    def dc_mesh_bondwires(self, value):
        if isinstance(value, bool):
            self._dc_mesh_bondwires = value

    @property
    def dc_num_bondwire_sides(self):
        """Retrieve the number of sides used for cylinder discretization.

        Returns
        -------
        int
            Number of sides.

        """
        return self._dc_num_bondwire_sides

    @dc_num_bondwire_sides.setter
    def dc_num_bondwire_sides(self, value):
        if isinstance(value, int):
            self._dc_num_bondwire_sides = value

    @property
    def dc_mesh_vias(self):
        """Retrieve the value for meshing vias.

        Returns
        -------
        bool
            ``True`` when activated, ``False`` deactivated.

        """
        return self._dc_mesh_vias

    @dc_mesh_vias.setter
    def dc_mesh_vias(self, value):
        if isinstance(value, bool):
            self._dc_mesh_vias = value

    @property
    def dc_num_via_sides(self):
        """Retrieve the number of sides used for cylinder discretization.

        Returns
        -------
        int
            Number of sides.

        """
        return self._dc_num_via_sides

    @dc_num_via_sides.setter
    def dc_num_via_sides(self, value):
        if isinstance(value, int):
            self._dc_num_via_sides = value

    @property
    def dc_percent_local_refinement(self):
        """Retrieve the value for local mesh refinement.

        Returns
        -------
        float
            The refinement value, 0.2 (20%) as default.

        """
        return self._dc_percent_local_refinement

    @dc_percent_local_refinement.setter
    def dc_percent_local_refinement(self, value):
        if isinstance(value, (int, float)):
            self._dc_percent_local_refinement = value

    @property
    def dc_perform_adaptive_refinement(self):
        """Retrieve the value for performing adaptive meshing.

        Returns
        -------
        bool
            ``True`` when activated, ``False`` deactivated.

        """
        return self._dc_perform_adaptive_refinement

    @dc_perform_adaptive_refinement.setter
    def dc_perform_adaptive_refinement(self, value):
        if isinstance(value, bool):
            self._dc_perform_adaptive_refinement = value

    @property
    def dc_refine_bondwires(self):
        """Retrieve the value for performing bond wire refinement.

        Returns
        -------
        bool
            ``True`` when activated, ``False`` deactivated.

        """
        return self._dc_refine_bondwires

    @dc_refine_bondwires.setter
    def dc_refine_bondwires(self, value):
        if isinstance(value, bool):
            self._dc_refine_bondwires = value

    @property
    def dc_refine_vias(self):
        """Retrieve the value for performing vias refinement.

        Returns
        -------
        bool
            ``True`` when activated, ``False`` deactivated.

        """
        return self._dc_refine_vias

    @dc_refine_vias.setter
    def dc_refine_vias(self, value):
        if isinstance(value, bool):
            self._dc_refine_vias = value

    @property
    def dc_report_config_file(self):
        """Retrieve the report configuration file path.

        Returns
        -------
        str
            The file path.

        """
        return self._dc_report_config_file

    @dc_report_config_file.setter
    def dc_report_config_file(self, value):
        if isinstance(value, str):
            self._dc_report_config_file = value

    @property
    def dc_report_show_Active_devices(self):
        """Retrieve the value for showing active devices.

        Returns
        -------
        bool
            ``True`` when activated, ``False`` deactivated.

        """
        return self._dc_report_show_Active_devices

    @dc_report_show_Active_devices.setter
    def dc_report_show_Active_devices(self, value):
        if isinstance(value, bool):
            self._dc_report_show_Active_devices = value

    @property
    def dc_export_thermal_data(self):
        """Retrieve the value for using external data.

        Returns
        -------
            bool
            ``True`` when activated, ``False`` deactivated.

        """
        return self._dc_export_thermal_data

    @dc_export_thermal_data.setter
    def dc_export_thermal_data(self, value):
        if isinstance(value, bool):
            self._dc_export_thermal_data = value

    @property
    def dc_full_report_path(self):
        """Retrieve the path for the report.

        Returns
        -------
            str
            File path.

        """
        return self._dc_full_report_path

    @dc_full_report_path.setter
    def dc_full_report_path(self, value):
        if isinstance(value, str):
            self._dc_full_report_path = value

    @property
    def dc_icepak_temp_file(self):
        """Retrieve the icepak temp file path.

        Returns
        -------
            str
            File path.
        """
        return self._dc_icepak_temp_file

    @dc_icepak_temp_file.setter
    def dc_icepak_temp_file(self, value):
        if isinstance(value, str):
            self._dc_icepak_temp_file = value

    @property
    def dc_import_thermal_data(self):
        """Retrieve the value for importing thermal data.

        Returns
        -------
            bool
            ``True`` when activated,``False`` deactivated.

        """
        return self._dc_import_thermal_data

    @dc_import_thermal_data.setter
    def dc_import_thermal_data(self, value):
        if isinstance(value, bool):
            self._dc_import_thermal_data = value

    @property
    def dc_per_pin_res_path(self):
        """Retrieve the file path.

        Returns
        -------
            str
            The file path.
        """
        return self._dc_per_pin_res_path

    @dc_per_pin_res_path.setter
    def dc_per_pin_res_path(self, value):
        if isinstance(value, str):
            self._dc_per_pin_res_path = value

    @property
    def dc_per_pin_use_pin_format(self):
        """Retrieve the value for using pin format.

        Returns
        -------
            bool
        """
        return self._dc_per_pin_use_pin_format

    @dc_per_pin_use_pin_format.setter
    def dc_per_pin_use_pin_format(self, value):
        if isinstance(value, bool):
            self._dc_per_pin_use_pin_format = value

    @property
    def dc_use_loop_res_for_per_pin(self):
        """Retrieve the value for using the loop resistor per pin.

        Returns
        -------
            bool
        """
        return self._dc_use_loop_res_for_per_pin

    @dc_use_loop_res_for_per_pin.setter
    def dc_use_loop_res_for_per_pin(self, value):
        if isinstance(value, bool):
            self._dc_use_loop_res_for_per_pin = value

    @property
    def dc_via_report_path(self):
        """Retrieve the via report file path.

        Returns
        -------
            str
            The file path.

        """
        return self._dc_via_report_path

    @dc_via_report_path.setter
    def dc_via_report_path(self, value):
        if isinstance(value, str):
            self._dc_via_report_path = value

    @dc_via_report_path.setter
    def dc_via_report_path(self, value):
        if isinstance(value, str):
            self._dc_via_report_path = value

    @property
    def dc_source_terms_to_ground(self):
        """Retrieve the dictionary of grounded terminals.

        Returns
        -------
            Dictionary
            {str, int}, keys is source name, value int 0 unspecified, 1 negative node, 2 positive one.

        """
        return self._dc_source_terms_to_ground

    @dc_source_terms_to_ground.setter
    def dc_source_terms_to_ground(self, value):  # pragma: no cover
        if isinstance(value, OrderedDict):
            if len([k for k in value.keys() if isinstance(k, str)]) == len(value.keys()):
                if len([v for v in value.values() if isinstance(v, int)]) == len(value.values()):
                    self._dc_source_terms_to_ground = value


class SimulationConfigurationAc(object):
    """Contains all AC analysis settings.
    The class is part of `SimulationConfiguration` class as a property.

    """

    def __init__(self):
        self._sweep_interpolating = True
        self._use_q3d_for_dc = False
        self._relative_error = 0.005
        self._use_error_z0 = False
        self._percentage_error_z0 = 1
        self._enforce_causality = True
        self._enforce_passivity = False
        self._passivity_tolerance = 0.0001
        self._sweep_name = "Sweep1"
        self._radiation_box = RadiationBoxType.ConvexHull  # 'ConvexHull'
        self._start_freq = "0.0GHz"  # 0.0
        self._stop_freq = "10.0GHz"  # 10e9
        self._sweep_type = SweepType.Linear  # 'Linear'
        self._step_freq = "0.025GHz"  # 10e6
        self._decade_count = 100  # Newly Added
        self._mesh_freq = "3GHz"  # 5e9
        self._max_num_passes = 30
        self._max_mag_delta_s = 0.03
        self._min_num_passes = 1
        self._basis_order = BasisOrder.Mixed  # 'Mixed'
        self._do_lambda_refinement = True
        self._arc_angle = "30deg"  # 30
        self._start_azimuth = 0
        self._max_arc_points = 8
        self._use_arc_to_chord_error = True
        self._arc_to_chord_error = "1um"  # 1e-6
        self._defeature_abs_length = "1um"  # 1e-6
        self._defeature_layout = True
        self._minimum_void_surface = 0
        self._max_suf_dev = 1e-3
        self._process_padstack_definitions = False
        self._return_current_distribution = True
        self._ignore_non_functional_pads = True
        self._include_inter_plane_coupling = True
        self._xtalk_threshold = -50
        self._min_void_area = "0.01mm2"
        self._min_pad_area_to_mesh = "0.01mm2"
        self._snap_length_threshold = "2.5um"
        self._min_plane_area_to_mesh = "4mil2"  # Newly Added
        self._mesh_sizefactor = 0.0
        self._adaptive_type = AdaptiveType.SingleFrequency
        self._adaptive_low_freq = "0GHz"
        self._adaptive_high_freq = "20GHz"

    @property
    def sweep_interpolating(self):  # pragma: no cover
        """Retrieve boolean to add a sweep interpolating sweep.

        Returns
        -------
            bool
            ``True`` when a sweep interpolating is defined, ``False`` when a discrete one is defined instead.
        """

        return self._sweep_interpolating

    @sweep_interpolating.setter
    def sweep_interpolating(self, value):  # pragma: no cover
        if isinstance(value, bool):
            self._sweep_interpolating = value

    @property
    def use_q3d_for_dc(self):  # pragma: no cover
        """Retrieve boolean to Q3D solver for DC point value computation.

        Returns
        -------
            bool
            ``True`` when Q3D solver is used ``False`` when interpolating value is used instead.
        """

        return self._use_q3d_for_dc

    @use_q3d_for_dc.setter
    def use_q3d_for_dc(self, value):  # pragma: no cover
        if isinstance(value, bool):
            self._use_q3d_for_dc = value

    @property
    def relative_error(self):  # pragma: no cover
        """Retrieve relative error used for the interpolating sweep convergence.

        Returns
        -------
            float
            The value of the error interpolating sweep to reach the convergence criteria.
        """

        return self._relative_error

    @relative_error.setter
    def relative_error(self, value):  # pragma: no cover
        if isinstance(value, (int, float)):
            self._relative_error = value

    @property
    def use_error_z0(self):  # pragma: no cover
        """Retrieve value for the error on Z0 for the port.

        Returns
        -------
            float
            The Z0 value.
        """

        return self._use_error_z0

    @use_error_z0.setter
    def use_error_z0(self, value):  # pragma: no cover
        if isinstance(value, bool):
            self._use_error_z0 = value

    @property
    def percentage_error_z0(self):  # pragma: no cover
        """Retrieve boolean to perform the cutout during the project build.

        Returns
        -------
            bool
            ``True`` when clipping the design is applied ``False`` if not.
        """

        return self._percentage_error_z0

    @percentage_error_z0.setter
    def percentage_error_z0(self, value):  # pragma: no cover
        if isinstance(value, (int, float)):
            self._percentage_error_z0 = value

    @property
    def enforce_causality(self):  # pragma: no cover
        """Retrieve boolean to enforce causality for the frequency sweep.

        Returns
        -------
            bool
            ``True`` when causality is enforced ``False`` if not.
        """

        return self._enforce_causality

    @enforce_causality.setter
    def enforce_causality(self, value):  # pragma: no cover
        if isinstance(value, bool):
            self._enforce_causality = value

    @property
    def enforce_passivity(self):  # pragma: no cover
        """Retrieve boolean to enforce passivity for the frequency sweep.

        Returns
        -------
            bool
            ``True`` when passivity is enforced ``False`` if not.
        """
        return self._enforce_passivity

    @enforce_passivity.setter
    def enforce_passivity(self, value):  # pragma: no cover
        if isinstance(value, bool):
            self._enforce_passivity = value

    @property
    def passivity_tolerance(self):  # pragma: no cover
        """Retrieve the value for the passivity tolerance when used.

        Returns
        -------
            float
            The passivity tolerance criteria for the frequency sweep.
        """
        return self._passivity_tolerance

    @passivity_tolerance.setter
    def passivity_tolerance(self, value):  # pragma: no cover
        if isinstance(value, (int, float)):
            self._passivity_tolerance = value

    @property
    def sweep_name(self):  # pragma: no cover
        """Retrieve frequency sweep name.

        Returns
        -------
            str
            The name of the frequency sweep defined in the project.
        """
        return self._sweep_name

    @sweep_name.setter
    def sweep_name(self, value):  # pragma: no cover
        if isinstance(value, str):
            self._sweep_name = value

    @property
    def radiation_box(self):  # pragma: no cover
        """Retrieve RadiationBoxType object selection defined for the radiation box type.

        Returns
        -------
            RadiationBoxType object
            3 values can be chosen, Conformal, BoundingBox or ConvexHull.
        """
        return self._radiation_box

    @radiation_box.setter
    def radiation_box(self, value):
        if validate_enum_class_value(RadiationBoxType, value):
            self._radiation_box = value

    @property
    def start_freq(self):  # pragma: no cover
        """Starting frequency for the frequency sweep.

        Returns
        -------
        float
            Value of the frequency point.
        """
        return self._start_freq

    @start_freq.setter
    def start_freq(self, value):  # pragma: no cover
        if isinstance(value, str):
            self._start_freq = value

    @property
    def stop_freq(self):  # pragma: no cover
        """Retrieve stop frequency for the frequency sweep.

        Returns
        -------
            float
            The value of the frequency point.
        """
        return self._stop_freq

    @stop_freq.setter
    def stop_freq(self, value):  # pragma: no cover
        if isinstance(value, str):
            self._stop_freq = value

    @property
    def sweep_type(self):  # pragma: no cover
        """Retrieve SweepType object for the frequency sweep.

        Returns
        -------
            SweepType
            The SweepType object,2 selections are supported Linear and LogCount.
        """
        return self._sweep_type

    @sweep_type.setter
    def sweep_type(self, value):  # pragma: no cover
        if validate_enum_class_value(SweepType, value):
            self._sweep_type = value

    @property
    def step_freq(self):  # pragma: no cover
        """Retrieve step frequency for the frequency sweep.

        Returns
        -------
            float
            The value of the frequency point.
        """
        return self._step_freq

    @step_freq.setter
    def step_freq(self, value):  # pragma: no cover
        if isinstance(value, str):
            self._step_freq = value

    @property
    def decade_count(self):  # pragma: no cover
        """Retrieve decade count number for the frequency sweep in case of a log sweep selected.

        Returns
        -------
            int
            The value of the decade count number.
        """
        return self._decade_count

    @decade_count.setter
    def decade_count(self, value):  # pragma: no cover
        if isinstance(value, int):
            self._decade_count = value

    @property
    def mesh_freq(self):
        """Retrieve the meshing frequency for the HFSS adaptive convergence.

        Returns
        -------
            float
            The value of the frequency point.
        """
        return self._mesh_freq

    @mesh_freq.setter
    def mesh_freq(self, value):  # pragma: no cover
        if isinstance(value, str):
            self._mesh_freq = value

    @property
    def max_num_passes(self):  # pragma: no cover
        """Retrieve maximum of points for the HFSS adaptive meshing.

        Returns
        -------
            int
            The maximum number of adaptive passes value.
        """
        return self._max_num_passes

    @max_num_passes.setter
    def max_num_passes(self, value):  # pragma: no cover
        if isinstance(value, int):
            self._max_num_passes = value

    @property
    def max_mag_delta_s(self):  # pragma: no cover
        """Retrieve the magnitude of the delta S convergence criteria for the interpolating sweep.

        Returns
        -------
            float
            The value of convergence criteria.
        """
        return self._max_mag_delta_s

    @max_mag_delta_s.setter
    def max_mag_delta_s(self, value):  # pragma: no cover
        if isinstance(value, (int, float)):
            self._max_mag_delta_s = value

    @property
    def min_num_passes(self):  # pragma: no cover
        """Retrieve the minimum number of adaptive passes for HFSS convergence.

        Returns
        -------
            int
            The value of minimum number of adaptive passes.
        """
        return self._min_num_passes

    @min_num_passes.setter
    def min_num_passes(self, value):  # pragma: no cover
        if isinstance(value, int):
            self._min_num_passes = value

    @property
    def basis_order(self):  # pragma: no cover
        """Retrieve the BasisOrder object.

        Returns
        -------
            BasisOrder class
            This class supports 4 selections Mixed, Zero, single and Double for the HFSS order matrix.
        """
        return self._basis_order

    @basis_order.setter
    def basis_order(self, value):  # pragma: no cover
        if validate_enum_class_value(BasisOrder, value):
            self._basis_order = value

    @property
    def do_lambda_refinement(self):  # pragma: no cover
        """Retrieve boolean to activate the lambda refinement.

        Returns
        -------
            bool
            ``True`` Enable the lambda meshing refinement with HFSS, ``False`` deactivate.
        """
        return self._do_lambda_refinement

    @do_lambda_refinement.setter
    def do_lambda_refinement(self, value):  # pragma: no cover
        if isinstance(value, bool):
            self._do_lambda_refinement = value

    @property
    def arc_angle(self):  # pragma: no cover
        """Retrieve the value for the HFSS meshing arc angle.

        Returns
        -------
            float
            Value of the arc angle.
        """
        return self._arc_angle

    @arc_angle.setter
    def arc_angle(self, value):  # pragma: no cover
        if isinstance(value, str):
            self._arc_angle = value

    @property
    def start_azimuth(self):  # pragma: no cover
        """Retrieve the value of the starting azimuth for the HFSS meshing.

        Returns
        -------
            float
            Value of the starting azimuth.
        """
        return self._start_azimuth

    @start_azimuth.setter
    def start_azimuth(self, value):  # pragma: no cover
        if isinstance(value, (int, float)):
            self._start_azimuth = value

    @property
    def max_arc_points(self):  # pragma: no cover
        """Retrieve the value of the maximum arc points number for the HFSS meshing.

        Returns
        -------
            int
            Value of the maximum arc point number.
        """
        return self._max_arc_points

    @max_arc_points.setter
    def max_arc_points(self, value):  # pragma: no cover
        if isinstance(value, int):
            self._max_arc_points = value

    @property
    def use_arc_to_chord_error(self):  # pragma: no cover
        """Retrieve the boolean for activating the arc to chord for HFSS meshing.

        Returns
        -------
            bool
            Activate when ``True``, deactivated when ``False``.
        """
        return self._use_arc_to_chord_error

    @use_arc_to_chord_error.setter
    def use_arc_to_chord_error(self, value):  # pragma: no cover
        if isinstance(value, bool):
            self._use_arc_to_chord_error = value

    @property
    def arc_to_chord_error(self):  # pragma: no cover
        """Retrieve the value of arc to chord error for HFSS meshing.

        Returns
        -------
            flot
            Value of the arc to chord error.
        """
        return self._arc_to_chord_error

    @arc_to_chord_error.setter
    def arc_to_chord_error(self, value):  # pragma: no cover
        if isinstance(value, str):
            self._arc_to_chord_error = value

    @property
    def defeature_abs_length(self):  # pragma: no cover
        """Retrieve the value of arc to chord for HFSS meshing.

        Returns
        -------
            flot
            Value of the arc to chord error.
        """
        return self._defeature_abs_length

    @defeature_abs_length.setter
    def defeature_abs_length(self, value):  # pragma: no cover
        if isinstance(value, str):
            self._defeature_abs_length = value

    @property
    def defeature_layout(self):  # pragma: no cover
        """Retrieve the boolean to activate the layout defeaturing.This method has been developed to simplify polygons
        with reducing the number of points to simplify the meshing with controlling its surface deviation. This method
        should be used at last resort when other methods failed.

        Returns
        -------
            bool
            ``True`` when activated 'False when deactivated.
        """
        return self._defeature_layout

    @defeature_layout.setter
    def defeature_layout(self, value):  # pragma: no cover
        if isinstance(value, bool):
            self._defeature_layout = value

    @property
    def minimum_void_surface(self):  # pragma: no cover
        """Retrieve the minimum void surface to be considered for the layout defeaturing.
        Voids below this value will be ignored.

        Returns
        -------
            flot
            Value of the minimum surface.
        """
        return self._minimum_void_surface

    @minimum_void_surface.setter
    def minimum_void_surface(self, value):  # pragma: no cover
        if isinstance(value, (int, float)):
            self._minimum_void_surface = value

    @property
    def max_suf_dev(self):  # pragma: no cover
        """Retrieve the value for the maximum surface deviation for the layout defeaturing.

        Returns
        -------
            flot
            Value of maximum surface deviation.
        """
        return self._max_suf_dev

    @max_suf_dev.setter
    def max_suf_dev(self, value):  # pragma: no cover
        if isinstance(value, (int, float)):
            self._max_suf_dev = value

    @property
    def process_padstack_definitions(self):  # pragma: no cover
        """Retrieve the boolean for activating the padstack definition processing.

        Returns
        -------
            flot
            Value of the arc to chord error.
        """
        return self._process_padstack_definitions

    @process_padstack_definitions.setter
    def process_padstack_definitions(self, value):  # pragma: no cover
        if isinstance(value, bool):
            self._process_padstack_definitions = value

    @property
    def return_current_distribution(self):  # pragma: no cover
        """Boolean to activate the current distribution return with Siwave.

        Returns
        -------
            flot
            Value of the arc to chord error.
        """
        return self._return_current_distribution

    @return_current_distribution.setter
    def return_current_distribution(self, value):  # pragma: no cover
        if isinstance(value, bool):
            self._return_current_distribution = value

    @property
    def ignore_non_functional_pads(self):  # pragma: no cover
        """Boolean to ignore nonfunctional pads with Siwave.

        Returns
         -------
            flot
            Value of the arc to chord error.
        """
        return self._ignore_non_functional_pads

    @ignore_non_functional_pads.setter
    def ignore_non_functional_pads(self, value):  # pragma: no cover
        if isinstance(value, bool):
            self._ignore_non_functional_pads = value

    @property
    def include_inter_plane_coupling(self):  # pragma: no cover
        """Boolean to activate the inter-plane coupling with Siwave.

        Returns
        -------
            bool
            ``True`` activated ``False`` deactivated.
        """
        return self._include_inter_plane_coupling

    @include_inter_plane_coupling.setter
    def include_inter_plane_coupling(self, value):  # pragma: no cover
        if isinstance(value, bool):
            self._include_inter_plane_coupling = value

    @property
    def xtalk_threshold(self):  # pragma: no cover
        """Return the value for Siwave cross talk threshold. THis value specifies the distance for the solver to
        consider lines coupled during the cross-section computation. Decreasing the value below -60dB can
        potentially cause solver failure.

        Returns
        -------
            flot
            Value of cross-talk threshold.
        """
        return self._xtalk_threshold

    @xtalk_threshold.setter
    def xtalk_threshold(self, value):  # pragma: no cover
        if isinstance(value, (int, float)):
            self._xtalk_threshold = value

    @property
    def min_void_area(self):  # pragma: no cover
        """Retrieve the value of minimum void area to be considered by Siwave.

        Returns
        -------
            flot
            Value of the arc to chord error.
        """
        return self._min_void_area

    @min_void_area.setter
    def min_void_area(self, value):  # pragma: no cover
        if isinstance(value, str):
            self._min_void_area = value

    @property
    def min_pad_area_to_mesh(self):  # pragma: no cover
        """Retrieve the value of minimum pad area to be meshed by Siwave.

        Returns
        -------
            flot
            Value of minimum pad surface.
        """
        return self._min_pad_area_to_mesh

    @min_pad_area_to_mesh.setter
    def min_pad_area_to_mesh(self, value):  # pragma: no cover
        if isinstance(value, str):
            self._min_pad_area_to_mesh = value

    @property
    def snap_length_threshold(self):  # pragma: no cover
        """Retrieve the boolean to activate the snapping threshold feature.

        Returns
        -------
            bool
            ``True`` activate ``False`` deactivated.
        """
        return self._snap_length_threshold

    @snap_length_threshold.setter
    def snap_length_threshold(self, value):  # pragma: no cover
        if isinstance(value, str):
            self._snap_length_threshold = value

    @property
    def min_plane_area_to_mesh(self):  # pragma: no cover
        """Retrieve the minimum plane area to be meshed by Siwave.

        Returns
        -------
            flot
            Value of the minimum plane area.
        """
        return self._min_plane_area_to_mesh

    @min_plane_area_to_mesh.setter
    def min_plane_area_to_mesh(self, value):  # pragma: no cover
        if isinstance(value, str):
            self._min_plane_area_to_mesh = value

    @property
    def mesh_sizefactor(self):
        """Retrieve the Mesh Size factor value.

        Returns
        -------
        float
        """
        return self._mesh_sizefactor

    @mesh_sizefactor.setter
    def mesh_sizefactor(self, value):
        if isinstance(value, (int, float)):
            self._mesh_sizefactor = value
            if value > 0.0:
                self._do_lambda_refinement = False

    @property
    def adaptive_type(self):
        """HFSS adaptive type.

        Returns
        -------
        class: pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data.AdaptiveType
        """
        return self._adaptive_type

    @adaptive_type.setter
    def adaptive_type(self, value):
        if isinstance(value, int) and value in range(3):
            self._adaptive_type = value

    @property
    def adaptive_low_freq(self):
        """HFSS broadband low frequency adaptive meshing.

        Returns
        -------
        str
        """
        return self._adaptive_low_freq

    @adaptive_low_freq.setter
    def adaptive_low_freq(self, value):
        if isinstance(value, str):
            self._adaptive_low_freq = value

    @property
    def adaptive_high_freq(self):
        """HFSS broadband high frequency adaptive meshing.

        Returns
        -------
        str
        """
        return self._adaptive_high_freq

    @adaptive_high_freq.setter
    def adaptive_high_freq(self, value):
        if isinstance(value, str):
            self._adaptive_high_freq = value


class SimulationConfiguration(object):
    """Provides an ASCII simulation configuration file parser.

    This parser supports all types of inputs for setting up and automating any kind
    of SI or PI simulation with HFSS 3D Layout or Siwave. If fields are omitted, default
    values are applied. This class can be instantiated directly from
    Configuration file.

    Examples
    --------
    This class is very convenient to build HFSS and SIwave simulation projects from layout.
    It is leveraging EDB commands from Pyaedt but with keeping high level parameters making more easy PCB automation
    flow. SYZ and DC simulation can be addressed with this class.

    The class is instantiated from an open edb:

    >>> from pyedb import Edb
    >>> edb = Edb()
    >>> sim_setup = edb.new_simulation_configuration()

    The returned object sim_setup is a SimulationConfiguration object.
    From this class you can assign a lot of parameters related the project configuration but also solver options.
    Here is the list of parameters available:

    >>> from dotnet.generic.constants import SolverType
    >>> sim_setup.solver_type = SolverType.Hfss3dLayout

    Solver type can be selected, HFSS 3D Layout and Siwave are supported.


    >>> sim_setup.signal_nets = ["net1", "net2"]

    Set the list of net names you want to include for the simulation. These nets will
    have excitations ports created if corresponding pins are found on selected component. We usually refer to signal
    nets but power / reference nets can also be passed into this list if user wants to have ports created on these ones.

    >>> sim_setup.power_nets = ["gnd", "vcc"]

    Set the list on power and reference nets. These nets won't have excitation ports created
    on them and will be clipped during the project build if the cutout option is enabled.

    >>> sim_setup.components = ["comp1", "comp2"]

    Set the list of components which will be included in the simulation. These components will have ports created on
    pins belonging to the net list.

    >>> sim_setup.do_cutout_subdesign = True

    When true activates the layout cutout based on net signal net selection and cutout expansion.

    >>> from dotnet.generic.constants import CutoutSubdesignType
    >>> sim_setup.cutout_subdesign_type = CutoutSubdesignType.Conformal

    Define the type of cutout used for computing the clippingextent polygon. CutoutSubdesignType.Conformal
    CutoutSubdesignType.BBox are surpported.

    >>> sim_setup.cutout_subdesign_expansion = "4mm"

    Define the distance used for computing the extent polygon. Integer or string can be passed.
    For example 0.001 is in meter so here 1mm. You can also pass the string "1mm" for the same result.

    >>> sim_setup.cutout_subdesign_round_corner = True

    Boolean to allow using rounded corner for the cutout extent or not.

    >>> sim_setup.use_default_cutout = False

    When True use the native edb API command to process the cutout. Using False uses
    the Pyaedt one which improves the cutout speed.

    >>> sim_setup.generate_solder_balls = True

    Boolean to activate the solder ball generation on components. When HFSS solver is selected in combination with this
    parameter, coaxial ports will be created on solder balls for pins belonging to selected signal nets. If Siwave
    solver is selected this parameter will be ignored.

    >>> sim_setup.use_default_coax_port_radial_extension = True

    When ``True`` the default coaxial extent is used for the ports (only for HFSS).
    When the design is having dense solder balls close to each other (like typically package design), the default value
    might be too large and cause port overlapping, then solver failure. To prevent this issue set this parameter to
    ``False`` will use a smaller value.

    >>> sim_setup.output_aedb = r"C:\temp\my_edb.aedb"

    Specify the output edb file after building the project. The parameter must be the complete file path.
    leaving this parameter blank will oervwritte the current open edb.

    >>>  sim_setup.dielectric_extent = 0.01

    Gives the dielectric extent after cutout, keeping default value is advised unless for
    very specific application.

    >>> sim_setup.airbox_horizontal_extent = "5mm"

    Provide the air box horizonzal extent values. Unitless float value will be
    treated as ratio but string value like "5mm" is also supported.

    >>> sim_setup.airbox_negative_vertical_extent = "5mm"

    Provide the air box negative vertical extent values. Unitless float value will be
    treated as ratio but string value like "5mm" is also supported.

    >>> sim_setup.airbox_positive_vertical_extent = "5mm"

    Provide the air box positive vertical extent values. Unitless float value will be
    treated as ratio but string value like "5mm" is also supported.

    >>> sim_setup.use_radiation_boundary = True

    When ``True`` use radiation airbox boundary condition and perfect metal box when
    set to ``False``. Default value is ``True``, using enclosed metal box will greatly change simulation results.
    Setting this parameter as ``False`` must be used cautiously.

    >>> sim_setup.do_cutout_subdesign = True

    ``True`` activates the cutout with associated parameters. Setting ``False`` will
    keep the entire layout.
    Setting to ``False`` can impact the simulation run time or even memory failure if HFSS solver is used.

    >>> sim_setup.do_pin_group = False

    When circuit ports are used, setting to ``True`` will force to create pin groups on
    components having pins belonging to same net. Setting to ``False`` will generate port on each signal pin with
    taking the closest reference pin. The last configuration is more often used when users are creating ports on PDN
    (Power delivery Network) and want to connect all pins individually.

    >>> from dotnet.generic.constants import SweepType
    >>> sim_setup.sweep_type = SweepType.Linear

    Specify the frequency sweep type, Linear or Log sweep can be defined.

    SimulationCOnfiguration also inherit from SimulationConfigurationAc class for High frequency settings.

    >>> sim_setup.start_freq = "OHz"

    Define the start frequency from the sweep.

    >>> sim_setup.stop_freq = "40GHz"

    Define the stop frequency from the sweep.

    >>> sim_setup.step_freq = "10MHz"

    Define the step frequency from the sweep.

    >>> sim_setup.decade_count = 100

    Used when log sweep is defined and specify the number of points per decade.

    >>> sim_setup.enforce_causality = True

    Activate the option ``Enforce Causality`` for the solver, recommended for signal integrity application

    >>> sim_setup.enforce_passivity = True

    Activate the option ``Enforce Passivity`` for the solver, recommended for signal integrity application

    >>> sim_setup.do_lambda_refinement = True

    Activate the lambda refinement for the initial mesh (only for HFSS), default value is ``True``. Keeping this
    activated is highly recommended.

    >>> sim_setup.use_q3d_for_dc = False

    Enable when ``True`` the Q3D DC point computation. Only needed when very high accuracy is required for DC point.
    Can eventually cause extra computation time.

    >>> sim_setup.sweep_name = "Test_sweep"

    Define the frequency sweep name.

    >>> sim_setup.mesh_freq = "10GHz"

    Define the frequency used for adaptive meshing (available for both HFSS and SIwave).

    >>> from dotnet.generic.constants import RadiationBoxType
    >>> sim_setup.radiation_box = RadiationBoxType.ConvexHull

    Defined the radiation box type, Conformal, Bounding box and ConvexHull are supported (HFSS only).

    >>> sim_setup.max_num_passes= 30

    Default value is 30, specify the maximum number of adaptive passes (only HFSS). Reasonable high value is recommended
    to force the solver reaching the convergence criteria.

    >>> sim_setup.max_mag_delta_s = 0.02

    Define the convergence criteria

    >>> sim_setup.min_num_passes = 2

    specify the minimum number of consecutive coberged passes. Setting to 2 is a good practice to avoid converging on
    local minima.

    >>> from dotnet.generic.constants import BasisOrder
    >>> sim_setup.basis_order =  BasisOrder.Single

    Select the order basis (HFSS only), Zero, Single, Double and Mixed are supported. For Signal integrity Single or
    Mixed should be used.

    >>> sim_setup.minimum_void_surface = 0

    Only for Siwave, specify the minimum void surface to be meshed. Void with lower surface value will be ignored by
    meshing.

    SimulationConfiguration also inherits from SimulationDc class to handle DC simulation projects.

    >>> sim_setup.dc_compute_inductance = True

    ``True`` activate the DC loop inductance computation (Siwave only), ``False`` is deactivated.

    >>> sim_setup.dc_slide_position = 1

    The provided value must be between 0 and 2 and correspond ti the SIwave DC slide position in GUI.
    0 : coarse
    1 : medium accuracy
    2 : high accuracy

    >>> sim_setup.dc_plot_jv = True

    ``True`` activate the current / voltage plot with Siwave DC solver, ``False`` deactivate.

    >>> sim_setup.dc_error_energy = 0.02

    Fix the DC error convergence criteria. In this example 2% is defined.

    >>> sim_setup.dc_max_num_pass = 6

    Provide the maximum number of passes during Siwave DC adaptive meshing.

    >>> sim_setup.dc_min_num_pass = 1

    Provide the minimum number of passes during Siwave DC adaptive meshing.

    >>> sim_setup.dc_mesh_bondwires = True

    ``True`` bondwires are meshed, ``False`` bond wires are ignored during meshing.

    >>> sim_setup.dc_num_bondwire_sides = 8

    Gives the number of facets wirebonds are discretized.

    >>> sim_setup.dc_refine_vias = True

    ``True`` meshing refinement on nondwires activated during meshing process. Deactivated when set to ``False``.

    >>> sim_setup.dc_report_show_Active_devices = True

    Activate when ``True`` the components showing in the DC report.

    >>> sim_setup.dc_export_thermal_data = True

    ``True`` thermal data are exported for Icepak simulation.

    >>> sim_setup.dc_full_report_path = r"C:\temp\my_report.html"

    Provides the file path for the DC report.

    >>> sim_setup.dc_icepak_temp_file = r"C:\temp\my_file"

    Provides icepak temporary files location.

    >>> sim_setup.dc_import_thermal_data = False

    Import DC thermal data when `True``

    >>> sim_setup.dc_per_pin_res_path = r"C:\temp\dc_pin_res_file"
    Provides the resistance per pin file path.

    >>> sim_setup.dc_per_pin_use_pin_format = True

    When ``True`` activate the pin format.

    >>> sim_setup.dc_use_loop_res_for_per_pin = True

    Activate the loop resistance usage per pin when ``True``

    >>> sim_setup.dc_via_report_path = 'C:\\temp\\via_report_file'

    Define the via report path file.

    >>> sim_setup.add_current_source(name="test_isrc",
    >>>                                 current_value=1.2,
    >>>                                 phase_value=0.0,
    >>>                                 impedance=5e7,
    >>>                                 positive_node_component="comp1",
    >>>                                 positive_node_net="net1",
    >>>                                 negative_node_component="comp2",
    >>>                                 negative_node_net="net2"
    >>>                             )

    Define a current source.

    >>> sim_setup.add_dc_ground_source_term(source_name="test_isrc", node_to_ground=1)

    Define the pin from a source which has to be set to reference for DC simulation.

    >>> sim_setup.add_voltage_source(name="test_vsrc",
    >>>                                 current_value=1.33,
    >>>                                 phase_value=0.0,
    >>>                                 impedance=1e-6,
    >>>                                 positive_node_component="comp1",
    >>>                                 positive_node_net="net1",
    >>>                                 negative_node_component="comp2",
    >>>                                 negative_node_net="net2"
    >>>                             )

    Define a voltage source.

    >>> sim_setup.add_dc_ground_source_term(source_name="test_vsrc", node_to_ground=1)

    Define the pin from a source which has to be set to reference for DC simulation.

    >>> edb.build_simulation_project(sim_setup)

    Will build and save your project.
    """

    def __getattr__(self, item):
        if item in dir(self):
            return self.__getattribute__(item)
        elif item in dir(self.dc_settings):
            return self.dc_settings.__getattribute__(item)
        elif item in dir(self.ac_settings):
            return self.ac_settings.__getattribute__(item)
        elif item in dir(self.batch_solve_settings):
            return self.batch_solve_settings.__getattribute__(item)
        else:
            raise AttributeError("Attribute {} not present.".format(item))

    def __setattr__(self, key, value):
        if "_dc_settings" in dir(self) and key in dir(self._dc_settings):
            return self.dc_settings.__setattr__(key, value)
        elif "_ac_settings" in dir(self) and key in dir(self._ac_settings):
            return self.ac_settings.__setattr__(key, value)
        elif "_batch_solve_settings" in dir(self) and key in dir(self._batch_solve_settings):
            return self.batch_solve_settings.__setattr__(key, value)
        else:
            return super(SimulationConfiguration, self).__setattr__(key, value)

    def __init__(self, filename=None, edb=None):
        self._filename = filename
        self._open_edb_after_build = True
        self._dc_settings = SimulationConfigurationDc()
        self._ac_settings = SimulationConfigurationAc()
        self._batch_solve_settings = SimulationConfigurationBatch()
        self._setup_name = "Pyaedt_setup"
        self._solver_type = SolverType.Hfss3dLayout
        if self._filename and os.path.splitext(self._filename)[1] == ".json":
            self.import_json(filename)
        self._read_cfg()
        self._pedb = edb
        self.SOLVER_TYPE = SolverType

    @property
    def open_edb_after_build(self):
        """Either if open the Edb after the build or not.

        Returns
        -------
        bool
        """
        return self._open_edb_after_build

    @open_edb_after_build.setter
    def open_edb_after_build(self, value):
        if isinstance(value, bool):
            self._open_edb_after_build = value

    @property
    def dc_settings(self):
        # type: () -> SimulationConfigurationDc
        """DC Settings class.

        Returns
        -------
        :class:`pyedb.dotnet.edb_core.edb_data.simulation_configuration.SimulationConfigurationDc`
        """
        return self._dc_settings

    @property
    def ac_settings(self):
        # type: () -> SimulationConfigurationAc
        """AC Settings class.

        Returns
        -------
        :class:`pyedb.dotnet.edb_core.edb_data.simulation_configuration.SimulationConfigurationAc`
        """
        return self._ac_settings

    @property
    def batch_solve_settings(self):
        # type: () -> SimulationConfigurationBatch
        """Cutout and Batch Settings class.

        Returns
        -------
        :class:`pyedb.dotnet.edb_core.edb_data.simulation_configuration.SimulationConfigurationBatch`
        """
        return self._batch_solve_settings

    @pyedb_function_handler()
    def build_simulation_project(self):
        """Build active simulation project. This method requires to be run inside Edb Class.

        Returns
        -------
        bool"""
        return self._pedb.build_simulation_project(self)

    @property
    def solver_type(self):  # pragma: no cover
        """Retrieve the SolverType class to select the solver to be called during the project build.

        Returns
        -------
        :class:`dotnet.generic.constants.SolverType`
            selections are supported, Hfss3dLayout and Siwave.
        """
        return self._solver_type

    @solver_type.setter
    def solver_type(self, value):  # pragma: no cover
        if isinstance(value, int):
            self._solver_type = value

    @property
    def filename(self):  # pragma: no cover
        """Retrieve the file name loaded for mapping properties value.

        Returns
        -------
        str
            the absolute path for the filename.
        """
        return self._filename

    @filename.setter
    def filename(self, value):
        if isinstance(value, str):  # pragma: no cover
            self._filename = value

    @property
    def setup_name(self):
        """Retrieve setup name for the simulation.

        Returns
        -------
        str
            Setup name.
        """
        return self._setup_name

    @setup_name.setter
    def setup_name(self, value):
        if isinstance(value, str):  # pragma: no cover
            self._setup_name = value

    def _get_bool_value(self, value):  # pragma: no cover
        val = value.lower()
        if val in ("y", "yes", "t", "true", "on", "1"):
            return True
        elif val in ("n", "no", "f", "false", "off", "0"):
            return False
        else:
            raise ValueError("Invalid truth value %r" % (val,))

    def _get_list_value(self, value):  # pragma: no cover
        value = value[1:-1]
        if len(value) == 0:
            return []
        else:
            value = value.split(",")
            if isinstance(value, list):
                prop_values = [i.strip() for i in value]
            else:
                prop_values = [value.strip()]
            return prop_values

    @pyedb_function_handler()
    def add_dc_ground_source_term(self, source_name=None, node_to_ground=1):
        """Add a dc ground source terminal for Siwave.

        Parameters
        ----------
        source_name : str, optional
            The source name to assign the reference node to.
            Default value is ``None``.

        node_to_ground : int, optional
            Value must be ``0``: unspecified, ``1``: negative node, ``2``: positive node.
            Default value is ``1``.

        """
        if source_name:
            if node_to_ground in [0, 1, 2]:
                self._dc_source_terms_to_ground[source_name] = node_to_ground

    def _read_cfg(self):  # pragma: no cover
        """Configuration file reader.

        .. deprecated:: 0.6.78
           Use :func:`import_json` instead.

        Examples
        --------

        >>> from pyedb import Edb
        >>> from dotnet.edb_core.edb_data.simulation_configuration import SimulationConfiguration
        >>> config_file = path_configuration_file
        >>> source_file = path_to_edb_folder
        >>> edb = Edb(source_file)
        >>> sim_setup = SimulationConfiguration(config_file)
        >>> edb.build_simulation_project(sim_setup)
        >>> edb.save_edb()
        >>> edb.close_edb()
        """

        if not self.filename or not os.path.exists(self.filename):
            # raise Exception("{} does not exist.".format(self.filename))
            return

        try:
            with open(self.filename) as cfg_file:
                cfg_lines = cfg_file.read().split("\n")
                for line in cfg_lines:
                    if line.strip() != "":
                        if line.find("="):
                            i, prop_value = line.strip().split("=")
                            value = prop_value.replace("'", "").strip()
                            if i.lower().startswith("generatesolderballs"):
                                self.generate_solder_balls = self._get_bool_value(value)
                            elif i.lower().startswith("signalnets"):
                                self.signal_nets = value[1:-1].split(",") if value[0] == "[" else value.split(",")
                                self.signal_nets = [item.strip() for item in self.signal_nets]
                            elif i.lower().startswith("powernets"):
                                self.power_nets = value[1:-1].split(",") if value[0] == "[" else value.split(",")
                                self.power_nets = [item.strip() for item in self.power_nets]
                            elif i.lower().startswith("components"):
                                self.components = value[1:-1].split(",") if value[0] == "[" else value.split(",")
                                self.components = [item.strip() for item in self.components]
                            elif i.lower().startswith("coaxsolderballsdiams"):
                                self.coax_solder_ball_diameter = (
                                    value[1:-1].split(",") if value[0] == "[" else value.split(",")
                                )
                                self.coax_solder_ball_diameter = [
                                    item.strip() for item in self.coax_solder_ball_diameter
                                ]
                            elif i.lower().startswith("usedefaultcoaxportradialextentfactor"):
                                self.signal_nets = self._get_bool_value(value)
                            elif i.lower().startswith("trimrefsize"):
                                self.trim_reference_size = self._get_bool_value(value)
                            elif i.lower().startswith("cutoutsubdesigntype"):
                                if value.lower().startswith("conformal"):
                                    self.cutout_subdesign_type = CutoutSubdesignType.Conformal
                                elif value.lower().startswith("boundingbox"):
                                    self.cutout_subdesign_type = CutoutSubdesignType.BoundingBox
                                else:
                                    print("Unprocessed value for CutoutSubdesignType '{0}'".format(value))
                            elif i.lower().startswith("cutoutsubdesignexpansion"):
                                self.cutout_subdesign_expansion = value
                            elif i.lower().startswith("cutoutsubdesignroundcorners"):
                                self.cutout_subdesign_round_corner = self._get_bool_value(value)
                            elif i.lower().startswith("sweepinterpolating"):
                                self.sweep_interpolating = self._get_bool_value(value)
                            elif i.lower().startswith("useq3dfordc"):
                                self.use_q3d_for_dc = self._get_bool_value(value)
                            elif i.lower().startswith("relativeerrors"):
                                self.relative_error = float(value)
                            elif i.lower().startswith("useerrorz0"):
                                self.use_error_z0 = self._get_bool_value(value)
                            elif i.lower().startswith("percenterrorz0"):
                                self.percentage_error_z0 = float(value)
                            elif i.lower().startswith("enforcecausality"):
                                self.enforce_causality = self._get_bool_value(value)
                            elif i.lower().startswith("enforcepassivity"):
                                self.enforce_passivity = self._get_bool_value(value)
                            elif i.lower().startswith("passivitytolerance"):
                                self.passivity_tolerance = float(value)
                            elif i.lower().startswith("sweepname"):
                                self.sweep_name = value
                            elif i.lower().startswith("radiationbox"):
                                if value.lower().startswith("conformal"):
                                    self.radiation_box = RadiationBoxType.Conformal
                                elif value.lower().startswith("boundingbox"):
                                    self.radiation_box = RadiationBoxType.BoundingBox
                                elif value.lower().startswith("convexhull"):
                                    self.radiation_box = RadiationBoxType.ConvexHull
                                else:
                                    print("Unprocessed value for RadiationBox '{0}'".format(value))
                            elif i.lower().startswith("startfreq"):
                                self.start_freq = value
                            elif i.lower().startswith("stopfreq"):
                                self.stop_freq = value
                            elif i.lower().startswith("sweeptype"):
                                if value.lower().startswith("linear"):
                                    self.sweep_type = SweepType.Linear
                                elif value.lower().startswith("logcount"):
                                    self.sweep_type = SweepType.LogCount
                                else:
                                    print("Unprocessed value for SweepType '{0}'".format(value))
                            elif i.lower().startswith("stepfreq"):
                                self.step_freq = value
                            elif i.lower().startswith("decadecount"):
                                self.decade_count = int(value)
                            elif i.lower().startswith("mesh_freq"):
                                self.mesh_freq = value
                            elif i.lower().startswith("maxnumpasses"):
                                self.max_num_passes = int(value)
                            elif i.lower().startswith("maxmagdeltas"):
                                self.max_mag_delta_s = float(value)
                            elif i.lower().startswith("minnumpasses"):
                                self.min_num_passes = int(value)
                            elif i.lower().startswith("basisorder"):
                                if value.lower().startswith("mixed"):
                                    self.basis_order = BasisOrder.Mixed
                                elif value.lower().startswith("zero"):
                                    self.basis_order = BasisOrder.Zero
                                elif value.lower().startswith("first"):  # single
                                    self.basis_order = BasisOrder.Single
                                elif value.lower().startswith("second"):  # double
                                    self.basis_order = BasisOrder.Double
                                else:
                                    print("Unprocessed value for BasisOrder '{0}'".format(value))
                            elif i.lower().startswith("dolambdarefinement"):
                                self.do_lambda_refinement = self._get_bool_value(value)
                            elif i.lower().startswith("arcangle"):
                                self.arc_angle = value
                            elif i.lower().startswith("startazimuth"):
                                self.start_azimuth = float(value)
                            elif i.lower().startswith("maxarcpoints"):
                                self.max_arc_points = int(value)
                            elif i.lower().startswith("usearctochorderror"):
                                self.use_arc_to_chord_error = self._get_bool_value(value)
                            elif i.lower().startswith("arctochorderror"):
                                self.arc_to_chord_error = value
                            elif i.lower().startswith("defeatureabsLength"):
                                self.defeature_abs_length = value
                            elif i.lower().startswith("defeaturelayout"):
                                self.defeature_layout = self._get_bool_value(value)
                            elif i.lower().startswith("minimumvoidsurface"):
                                self.minimum_void_surface = float(value)
                            elif i.lower().startswith("maxsurfdev"):
                                self.max_suf_dev = float(value)
                            elif i.lower().startswith("processpadstackdefinitions"):
                                self.process_padstack_definitions = self._get_bool_value(value)
                            elif i.lower().startswith("returncurrentdistribution"):
                                self.return_current_distribution = self._get_bool_value(value)
                            elif i.lower().startswith("ignorenonfunctionalpads"):
                                self.ignore_non_functional_pads = self._get_bool_value(value)
                            elif i.lower().startswith("includeinterplanecoupling"):
                                self.include_inter_plane_coupling = self._get_bool_value(value)
                            elif i.lower().startswith("xtalkthreshold"):
                                self.xtalk_threshold = float(value)
                            elif i.lower().startswith("minvoidarea"):
                                self.min_void_area = value
                            elif i.lower().startswith("minpadareatomesh"):
                                self.min_pad_area_to_mesh = value
                            elif i.lower().startswith("snaplengththreshold"):
                                self.snap_length_threshold = value
                            elif i.lower().startswith("minplaneareatomesh"):
                                self.min_plane_area_to_mesh = value
                            elif i.lower().startswith("dcminplaneareatomesh"):
                                self.dc_min_plane_area_to_mesh = value
                            elif i.lower().startswith("maxinitmeshedgelength"):
                                self.max_init_mesh_edge_length = value
                            elif i.lower().startswith("signallayersproperties"):
                                self._parse_signal_layer_properties = value[1:-1] if value[0] == "[" else value
                                self._parse_signal_layer_properties = [
                                    item.strip() for item in self._parse_signal_layer_properties
                                ]
                            elif i.lower().startswith("coplanar_instances"):
                                self.coplanar_instances = value[1:-1] if value[0] == "[" else value
                                self.coplanar_instances = [item.strip() for item in self.coplanar_instances]
                            elif i.lower().startswith("signallayersetching"):
                                self.signal_layer_etching_instances = value[1:-1] if value[0] == "[" else value
                                self.signal_layer_etching_instances = [
                                    item.strip() for item in self.signal_layer_etching_instances
                                ]
                            elif i.lower().startswith("etchingfactor"):
                                self.etching_factor_instances = value[1:-1] if value[0] == "[" else value
                                self.etching_factor_instances = [item.strip() for item in self.etching_factor_instances]
                            elif i.lower().startswith("docutoutsubdesign"):
                                self.do_cutout_subdesign = self._get_bool_value(value)
                            elif i.lower().startswith("solvertype"):
                                if value.lower() == "hfss":
                                    self.solver_type = 0
                                if value.lower() == "hfss3dlayout":
                                    self.solver_type = 6
                                elif value.lower().startswith("siwavesyz"):
                                    self.solver_type = 7
                                elif value.lower().startswith("siwavedc"):
                                    self.solver_type = 8
                                elif value.lower().startswith("q3d"):
                                    self.solver_type = 2
                                elif value.lower().startswith("nexxim"):
                                    self.solver_type = 4
                                elif value.lower().startswith("maxwell"):
                                    self.solver_type = 3
                                elif value.lower().startswith("twinbuilder"):
                                    self.solver_type = 5
                                else:
                                    self.solver_type = SolverType.Hfss3dLayout
                        else:
                            print("Unprocessed line in cfg file: {0}".format(line))
                    else:
                        continue
        except EnvironmentError as e:
            print("Error reading cfg file: {}".format(e.message))
            raise

    def _dict_to_json(self, dict_out, dict_in=None):
        exclude = ["_pedb", "SOLVER_TYPE"]
        for k, v in dict_in.items():
            if k in exclude:
                continue
            if k[0] == "_":
                if k[1:] in ["dc_settings", "ac_settings", "batch_solve_settings"]:
                    dict_out[k[1:]] = {}
                    dict_out[k[1:]] = self._dict_to_json(dict_out[k[1:]], self.__getattr__(k).__dict__)
                elif k == "_sources":
                    sources_out = [src._json_format() for src in v]
                    dict_out[k[1:]] = sources_out
                elif k == "_dc_source_terms_to_ground":
                    dc_term_gnd = {}
                    for k2 in list(v.Keys):  # pragma: no cover
                        dc_term_gnd[k2] = v[k2]
                    dict_out[k[1:]] = dc_term_gnd
                else:
                    dict_out[k[1:]] = v
            else:
                dict_out[k] = v
        return dict_out

    def _json_to_dict(self, json_dict):
        for k, v in json_dict.items():
            if k == "sources":
                for src in json_dict[k]:  # pragma: no cover
                    source = Source()
                    source._read_json(src)
                    self.batch_solve_settings.sources.append(source)
            elif k == "dc_source_terms_to_ground":
                dc_term_gnd = Dictionary[str, int]()
                for k1, v1 in json_dict[k]:  # pragma: no cover
                    dc_term_gnd[k1] = v1
                self.dc_source_terms_to_ground = dc_term_gnd
            elif k in ["dc_settings", "ac_settings", "batch_solve_settings"]:
                self._json_to_dict(v)
            else:
                self.__setattr__(k, v)

    @pyedb_function_handler()
    def export_json(self, output_file):
        """Export Json file from SimulationConfiguration object.

        Parameters
        ----------
        output_file : str
            Json file name.

        Returns
        -------
        bool
            True when succeeded False when file name not provided.

        Examples
        --------

        >>> from dotnet.edb_core.edb_data.simulation_configuration import SimulationConfiguration
        >>> config = SimulationConfiguration()
        >>> config.export_json(r"C:\Temp\test_json\test.json")
        """
        dict_out = {}
        dict_out = self._dict_to_json(dict_out, self.__dict__)
        if output_file:
            with open(output_file, "w") as write_file:
                json.dump(dict_out, write_file, indent=4)
            return True
        else:
            return False

    @pyedb_function_handler()
    def import_json(self, input_file):
        """Import Json file into SimulationConfiguration object instance.

        Parameters
        ----------
        input_file : str
            Json file name.

        Returns
        -------
        bool
            True when succeeded False when file name not provided.

        Examples
        --------
        >>> from dotnet.edb_core.edb_data.simulation_configuration import SimulationConfiguration
        >>> test = SimulationConfiguration()
        >>> test.import_json(r"C:\Temp\test_json\test.json")
        """
        if input_file:
            f = open(input_file)
            json_dict = json.load(f)  # pragma: no cover
            self._json_to_dict(json_dict)
            self.filename = input_file
            return True
        else:
            return False

    @pyedb_function_handler()
    def add_voltage_source(
        self,
        name="",
        voltage_value=1,
        phase_value=0,
        impedance=1e-6,
        positive_node_component="",
        positive_node_net="",
        negative_node_component="",
        negative_node_net="",
    ):
        """Add a voltage source for the current SimulationConfiguration instance.

        Parameters
        ----------
        name : str
            Source name.

        voltage_value : float
            Amplitude value of the source. Either amperes for current source or volts for
            voltage source.

        phase_value : float
            Phase value of the source.

        impedance : float
            Impedance value of the source.

        positive_node_component : str
            Name of the component used for the positive node.

        negative_node_component : str
            Name of the component used for the negative node.

        positive_node_net : str
            Net used for the positive node.

        negative_node_net : str
            Net used for the negative node.

        Returns
        -------
        bool
            ``True`` when successful, ``False`` when failed.

        Examples
        --------
        >>> edb = Edb(target_file)
        >>> sim_setup = SimulationConfiguration()
        >>> sim_setup.add_voltage_source(voltage_value=1.0, phase_value=0, positive_node_component="V1",
        >>> positive_node_net="HSG", negative_node_component="V1", negative_node_net="SW")

        """
        if name == "":  # pragma: no cover
            name = generate_unique_name("v_source")
        source = Source()
        source.source_type = SourceType.Vsource
        source.name = name
        source.amplitude = voltage_value
        source.phase = phase_value
        source.positive_node.component = positive_node_component
        source.positive_node.net = positive_node_net
        source.negative_node.component = negative_node_component
        source.negative_node.net = negative_node_net
        source.impedance_value = impedance
        try:  # pragma: no cover
            self.sources.append(source)
            return True
        except:  # pragma: no cover
            return False

    @pyedb_function_handler()
    def add_current_source(
        self,
        name="",
        current_value=0.1,
        phase_value=0,
        impedance=5e7,
        positive_node_component="",
        positive_node_net="",
        negative_node_component="",
        negative_node_net="",
    ):
        """Add a current source for the current SimulationConfiguration instance.

        Parameters
        ----------
        name : str
            Source name.

        current_value : float
            Amplitude value of the source. Either amperes for current source or volts for
            voltage source.

        phase_value : float
            Phase value of the source.

        impedance : float
            Impedance value of the source.

        positive_node_component : str
            Name of the component used for the positive node.

        negative_node_component : str
            Name of the component used for the negative node.

        positive_node_net : str
            Net used for the positive node.

        negative_node_net : str
            Net used for the negative node.

        Returns
        -------
        bool
            ``True`` when successful, ``False`` when failed.

        Examples
        --------
        >>> edb = Edb(target_file)
        >>> sim_setup = SimulationConfiguration()
        >>> sim_setup.add_voltage_source(voltage_value=1.0, phase_value=0, positive_node_component="V1",
        >>> positive_node_net="HSG", negative_node_component="V1", negative_node_net="SW")
        """

        if name == "":  # pragma: no cover
            name = generate_unique_name("I_source")
        source = Source()
        source.source_type = SourceType.Isource
        source.name = name
        source.amplitude = current_value
        source.phase = phase_value
        source.positive_node.component = positive_node_component
        source.positive_node.net = positive_node_net
        source.negative_node.component = negative_node_component
        source.negative_node.net = negative_node_net
        source.impedance_value = impedance
        try:  # pragma: no cover
            self.sources.append(source)
            return True
        except:  # pragma: no cover
            return False

    @pyedb_function_handler()
    def add_rlc(
        self,
        name="",
        r_value=1.0,
        c_value=0.0,
        l_value=0.0,
        positive_node_component="",
        positive_node_net="",
        negative_node_component="",
        negative_node_net="",
        create_physical_rlc=True,
    ):
        """Add a voltage source for the current SimulationConfiguration instance.

        Parameters
        ----------
        name : str
            Source name.

        r_value : float
            Resistor value in Ohms.

        l_value : float
            Inductance value in Henry.

        c_value : float
            Capacitance value in Farrad.

        positive_node_component : str
            Name of the component used for the positive node.

        negative_node_component : str
            Name of the component used for the negative node.

        positive_node_net : str
            Net used for the positive node.

        negative_node_net : str
            Net used for the negative node.

        create_physical_rlc : bool
            When True create a physical Rlc component. Recommended setting to True to be compatible with Siwave.

        Returns
        -------
        bool
            ``True`` when successful, ``False`` when failed.

        Examples
        --------
        >>> edb = Edb(target_file)
        >>> sim_setup = SimulationConfiguration()
        >>> sim_setup.add_voltage_source(voltage_value=1.0, phase_value=0, positive_node_component="V1",
        >>> positive_node_net="HSG", negative_node_component="V1", negative_node_net="SW")
        """

        if name == "":  # pragma: no cover
            name = generate_unique_name("Rlc")
        source = Source()
        source.source_type = SourceType.Rlc
        source.name = name
        source.r_value = r_value
        source.l_value = l_value
        source.c_value = c_value
        source.create_physical_resistor = create_physical_rlc
        source.positive_node.component = positive_node_component
        source.positive_node.net = positive_node_net
        source.negative_node.component = negative_node_component
        source.negative_node.net = negative_node_net
        try:  # pragma: no cover
            self.sources.append(source)
            return True
        except:  # pragma: no cover
            return False