siliconcompiler 0.36.0__py3-none-any.whl → 0.36.2__py3-none-any.whl

siliconcompiler/tools/openroad/antenna_repair.py

@@ -1,3 +1,5 @@
+from typing import Optional, Union
+
 from siliconcompiler import TaskSkip
 from siliconcompiler.tools.openroad._apr import APRTask
 from siliconcompiler.tools.openroad._apr import OpenROADSTAParameter, OpenROADGRTParameter, \
@@ -19,6 +21,30 @@ class AntennaRepairTask(APRTask, OpenROADSTAParameter, OpenROADGRTParameter, Ope
                            "true/false, flag to indicate whether to repair antenna violations",
                            defvalue=True)
 
+    def set_openroad_antcheck(self, enable: bool,
+                              step: Optional[str] = None, index: Optional[Union[int, str]] = None):
+        """
+        Enables or disables checking for antenna violations.
+
+        Args:
+            enable (bool): True to check, False to skip.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "ant_check", enable, step=step, index=index)
+
+    def set_openroad_antrepair(self, enable: bool,
+                               step: Optional[str] = None, index: Optional[Union[int, str]] = None):
+        """
+        Enables or disables repairing antenna violations.
+
+        Args:
+            enable (bool): True to repair, False to skip.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "ant_repair", enable, step=step, index=index)
+
     def task(self):
         return "antenna_repair"
 

siliconcompiler/tools/openroad/fillmetal_insertion.py

@@ -1,3 +1,5 @@
+from typing import Optional, Union
+
 from siliconcompiler.tools.openroad._apr import APRTask
 from siliconcompiler.tools.openroad._apr import OpenROADSTAParameter
 
@@ -15,6 +17,18 @@ class FillMetalTask(APRTask, OpenROADSTAParameter):
                            "true/false, when true enables adding fill, "
                            "if enabled by the PDK, to the design", defvalue=True)
 
+    def set_openroad_addfill(self, enable: bool,
+                             step: Optional[str] = None, index: Optional[Union[int, str]] = None):
+        """
+        Enables or disables adding fill to the design.
+
+        Args:
+            enable (bool): True to enable fill, False to disable.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "fin_add_fill", enable, step=step, index=index)
+
     def task(self):
         return "fillmetal_insertion"
 

siliconcompiler/tools/openroad/global_placement.py

@@ -1,3 +1,5 @@
+from typing import Optional, Union
+
 from siliconcompiler.tools.openroad._apr import APRTask
 from siliconcompiler.tools.openroad._apr import OpenROADSTAParameter, OpenROADGPLParameter, \
     OpenROADGRTGeneralParameter, OpenROADPPLParameter
@@ -24,6 +26,71 @@ class GlobalPlacementTask(APRTask, OpenROADSTAParameter, OpenROADGPLParameter,
                            "true/false, when true multibit clustering will be performed.",
                            defvalue=False)
 
+    def set_openroad_enablescanchains(self, enable: bool,
+                                      step: Optional[str] = None,
+                                      index: Optional[Union[int, str]] = None):
+        """
+        Enables or disables scan chain insertion.
+
+        Args:
+            enable (bool): True to enable, False to disable.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "enable_scan_chains", enable, step=step, index=index)
+
+    def set_openroad_scanenableportpattern(self, pattern: str,
+                                           step: Optional[str] = None,
+                                           index: Optional[Union[int, str]] = None):
+        """
+        Sets the pattern for the scan chain enable port.
+
+        Args:
+            pattern (str): The port pattern.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "scan_enable_port_pattern", pattern, step=step, index=index)
+
+    def set_openroad_scaninportpattern(self, pattern: str,
+                                       step: Optional[str] = None,
+                                       index: Optional[Union[int, str]] = None):
+        """
+        Sets the pattern for the scan chain input port.
+
+        Args:
+            pattern (str): The port pattern.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "scan_in_port_pattern", pattern, step=step, index=index)
+
+    def set_openroad_scanoutportpattern(self, pattern: str,
+                                        step: Optional[str] = None,
+                                        index: Optional[Union[int, str]] = None):
+        """
+        Sets the pattern for the scan chain output port.
+
+        Args:
+            pattern (str): The port pattern.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "scan_out_port_pattern", pattern, step=step, index=index)
+
+    def set_openroad_enablemultibitclustering(self, enable: bool,
+                                              step: Optional[str] = None,
+                                              index: Optional[Union[int, str]] = None):
+        """
+        Enables or disables multibit clustering.
+
+        Args:
+            enable (bool): True to enable, False to disable.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "enable_multibit_clustering", enable, step=step, index=index)
+
     def task(self):
         return "global_placement"
 

siliconcompiler/tools/openroad/global_route.py

@@ -1,3 +1,5 @@
+from typing import Optional, Union
+
 from siliconcompiler.tools.openroad._apr import APRTask
 from siliconcompiler.tools.openroad._apr import OpenROADSTAParameter, OpenROADGRTParameter, \
     OpenROADDRTPinAccessParameter
@@ -15,6 +17,19 @@ class GlobalRouteTask(APRTask, OpenROADSTAParameter, OpenROADGRTParameter,
                            "true/false, when true perform pin access before global routing",
                            defvalue=False)
 
+    def set_openroad_usepinaccess(self, enable: bool,
+                                  step: Optional[str] = None,
+                                  index: Optional[Union[int, str]] = None):
+        """
+        Enables or disables performing pin access before global routing.
+
+        Args:
+            enable (bool): True to enable, False to disable.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "grt_use_pin_access", enable, step=step, index=index)
+
     def task(self):
         return "global_route"
 

siliconcompiler/tools/openroad/init_floorplan.py

@@ -1,3 +1,5 @@
+import os.path
+
 from typing import Union, List, Optional
 
 from siliconcompiler.tools.openroad._apr import APRTask
@@ -27,6 +29,15 @@ class InitFloorplanTask(APRTask,
         self.add_parameter("padringfileset", "[str]", "filesets to generate a padring")
         self.add_parameter("bumpmapfileset", "[str]", "filesets to generate a bumpmap")
 
+        tools_root = os.path.dirname(os.path.dirname(__file__))
+        self.set_dataroot("sc-common", os.path.join(tools_root, "_common"))
+        self.add_parameter(
+            "sc_pin_constraints_tcl",
+            "file",
+            "TCL file defining pin constraints for use with OpenROAD.",
+            "tcl/sc_pin_constraints.tcl",
+            dataroot="sc-common")
+
     def set_openroad_snapstrategy(self, snap: str,
                                   step: Optional[str] = None, index: Optional[str] = None):
         """
@@ -157,6 +168,9 @@ class InitFloorplanTask(APRTask,
             if component.get_partname(step=self.step, index=self.index):
                 self.add_required_key(component, "partname")
 
+        if self.project.constraint.pin.get_pinconstraint():
+            self.add_required_key("var", "sc_pin_constraints_tcl")
+
         for pin in self.project.constraint.pin.get_pinconstraint().values():
             if pin.get_placement(step=self.step, index=self.index) is not None:
                 self.add_required_key(pin, "placement")

siliconcompiler/tools/openroad/macro_placement.py

@@ -1,3 +1,5 @@
+from typing import Union, List, Optional
+
 from siliconcompiler.tools.openroad._apr import APRTask
 from siliconcompiler.tools.openroad._apr import OpenROADSTAParameter, OpenROADGPLParameter
 
@@ -67,6 +69,256 @@ class MacroPlacementTask(APRTask, OpenROADSTAParameter, OpenROADGPLParameter):
         self.add_parameter("mpl_macro_blockage_weight", "float",
                            "Weight for macro blockage, or the overlapping instances of the macro")
 
+    def add_openroad_mplconstraints(self, constraints: Union[str, List[str]],
+                                    step: Optional[str] = None, index: Optional[str] = None,
+                                    clobber: bool = False):
+        """
+        Adds constraints scripts for macro placement.
+
+        Args:
+            constraints (Union[str, List[str]]): The constraint file(s) to add.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+            clobber (bool, optional): If True, overwrites the existing list. Defaults to False.
+        """
+        if clobber:
+            self.set("var", "mpl_constraints", constraints, step=step, index=index)
+        else:
+            self.add("var", "mpl_constraints", constraints, step=step, index=index)
+
+    def set_openroad_macroplacehalo(self, x: float, y: float,
+                                    step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Sets the macro halo to use when performing automated macro placement.
+
+        Args:
+            x (float): Halo in X direction (microns).
+            y (float): Halo in Y direction (microns).
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "macro_place_halo", (x, y), step=step, index=index)
+
+    def set_openroad_mplmininstances(self, count: int,
+                                     step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Sets the minimum number of instances to use while clustering for macro placement.
+
+        Args:
+            count (int): The minimum instance count.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "mpl_min_instances", count, step=step, index=index)
+
+    def set_openroad_mplmaxinstances(self, count: int,
+                                     step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Sets the maximum number of instances to use while clustering for macro placement.
+
+        Args:
+            count (int): The maximum instance count.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "mpl_max_instances", count, step=step, index=index)
+
+    def set_openroad_mplminmacros(self, count: int,
+                                  step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Sets the minimum number of macros to use while clustering for macro placement.
+
+        Args:
+            count (int): The minimum macro count.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "mpl_min_macros", count, step=step, index=index)
+
+    def set_openroad_mplmaxmacros(self, count: int,
+                                  step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Sets the maximum number of macros to use while clustering for macro placement.
+
+        Args:
+            count (int): The maximum macro count.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "mpl_max_macros", count, step=step, index=index)
+
+    def set_openroad_mplmaxlevels(self, levels: int,
+                                  step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Sets the maximum depth of the physical hierarchical tree.
+
+        Args:
+            levels (int): The maximum levels.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "mpl_max_levels", levels, step=step, index=index)
+
+    def set_openroad_mplminaspectratio(self, ratio: float,
+                                       step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Sets the minimum aspect ratio of width to height of a standard cell cluster.
+
+        Args:
+            ratio (float): The minimum aspect ratio.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "mpl_min_aspect_ratio", ratio, step=step, index=index)
+
+    def set_openroad_mplfence(self, llx: float, lly: float, urx: float, ury: float,
+                              step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Defines the global fence bounding box coordinates.
+
+        Args:
+            llx (float): Lower-left X coordinate (microns).
+            lly (float): Lower-left Y coordinate (microns).
+            urx (float): Upper-right X coordinate (microns).
+            ury (float): Upper-right Y coordinate (microns).
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "mpl_fence", (llx, lly, urx, ury), step=step, index=index)
+
+    def set_openroad_mplbusplanning(self, enable: bool,
+                                    step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Enables or disables bus planning.
+
+        Args:
+            enable (bool): True to enable, False to disable.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "mpl_bus_planning", enable, step=step, index=index)
+
+    def set_openroad_mpltargetdeadspace(self, percentage: float,
+                                        step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Sets the target dead space percentage.
+
+        Args:
+            percentage (float): The target dead space percentage.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "mpl_target_dead_space", percentage, step=step, index=index)
+
+    def set_openroad_mplareaweight(self, weight: float,
+                                   step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Sets the weight for the area of the current floorplan.
+
+        Args:
+            weight (float): The weight value.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "mpl_area_weight", weight, step=step, index=index)
+
+    def set_openroad_mploutlineweight(self, weight: float,
+                                      step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Sets the weight for violating the fixed outline constraint.
+
+        Args:
+            weight (float): The weight value.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "mpl_outline_weight", weight, step=step, index=index)
+
+    def set_openroad_mplwirelengthweight(self, weight: float,
+                                         step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Sets the weight for half-perimeter wirelength.
+
+        Args:
+            weight (float): The weight value.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "mpl_wirelength_weight", weight, step=step, index=index)
+
+    def set_openroad_mplguidanceweight(self, weight: float,
+                                       step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Sets the weight for guidance cost.
+
+        Args:
+            weight (float): The weight value.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "mpl_guidance_weight", weight, step=step, index=index)
+
+    def set_openroad_mplfenceweight(self, weight: float,
+                                    step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Sets the weight for fence cost.
+
+        Args:
+            weight (float): The weight value.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "mpl_fence_weight", weight, step=step, index=index)
+
+    def set_openroad_mplboundaryweight(self, weight: float,
+                                       step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Sets the weight for the boundary cost.
+
+        Args:
+            weight (float): The weight value.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "mpl_boundary_weight", weight, step=step, index=index)
+
+    def set_openroad_mplblockageweight(self, weight: float,
+                                       step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Sets the weight for the blockage cost.
+
+        Args:
+            weight (float): The weight value.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "mpl_blockage_weight", weight, step=step, index=index)
+
+    def set_openroad_mplnotchweight(self, weight: float,
+                                    step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Sets the weight for the notch cost.
+
+        Args:
+            weight (float): The weight value.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "mpl_notch_weight", weight, step=step, index=index)
+
+    def set_openroad_mplmacroblockageweight(self, weight: float,
+                                            step: Optional[str] = None,
+                                            index: Optional[str] = None):
+        """
+        Sets the weight for macro blockage cost.
+
+        Args:
+            weight (float): The weight value.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "mpl_macro_blockage_weight", weight, step=step, index=index)
+
     def task(self):
         return "macro_placement"
 

siliconcompiler/tools/openroad/power_grid.py

@@ -1,3 +1,5 @@
+from typing import Union, List, Optional
+
 from siliconcompiler.tools.openroad._apr import APRTask
 from siliconcompiler.tools.openroad._apr import OpenROADSTAParameter, OpenROADPSMParameter
 
@@ -26,6 +28,47 @@ class PowerGridTask(APRTask, OpenROADSTAParameter, OpenROADPSMParameter):
         else:
             self.add("var", "pdn_fileset", (library, fileset))
 
+    def set_openroad_fixedpinkeepout(self, keepout: float,
+                                     step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Sets the blockage multiplier for fixed pins to ensure routing room.
+
+        Args:
+            keepout (float): Blockage in multiples of routing pitch.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "fixed_pin_keepout", keepout, step=step, index=index)
+
+    def add_openroad_missingterminalnets(self, nets: Union[str, List[str]],
+                                         step: Optional[str] = None, index: Optional[str] = None,
+                                         clobber: bool = False):
+        """
+        Adds nets where missing terminals are acceptable.
+
+        Args:
+            nets (Union[str, List[str]]): The net(s) to add.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+            clobber (bool, optional): If True, overwrites the existing list. Defaults to False.
+        """
+        if clobber:
+            self.set("var", "psm_allow_missing_terminal_nets", nets, step=step, index=index)
+        else:
+            self.add("var", "psm_allow_missing_terminal_nets", nets, step=step, index=index)
+
+    def set_openroad_pdnenable(self, enable: bool,
+                               step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Enables or disables power grid generation.
+
+        Args:
+            enable (bool): True to enable, False to disable.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "pdn_enable", enable, step=step, index=index)
+
     def task(self):
         return "power_grid"
 
@@ -51,7 +94,7 @@ class PowerGridTask(APRTask, OpenROADSTAParameter, OpenROADPSMParameter):
 
     def __import_pdn_filesets(self):
         for lib in self.project.get("asic", "asiclib"):
-            libobj = self.project.get("library", lib, field="schema")
+            libobj = self.project.get_library(lib)
             if libobj.valid("tool", "openroad", "power_grid_fileset"):
                 for fileset in libobj.get("tool", "openroad", "power_grid_fileset"):
                     self.add_openroad_powergridfileset(lib, fileset)

siliconcompiler/tools/openroad/rcx_bench.py

@@ -1,3 +1,5 @@
+from typing import Optional, Union
+
 from siliconcompiler.tools.openroad import OpenROADTask
 
 
@@ -12,6 +14,32 @@ class ORXBenchTask(OpenROADTask):
         self.add_parameter("bench_length", "float", "Length of bench wires",
                            defvalue=100, units="um")
 
+    def set_openroad_benchmaxlayer(self, layer: str,
+                                   step: Optional[str] = None,
+                                   index: Optional[Union[int, str]] = None):
+        """
+        Sets the maximum layer to generate the extraction bench for.
+
+        Args:
+            layer (str): The layer name.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "max_layer", layer, step=step, index=index)
+
+    def set_openroad_benchlength(self, length: float,
+                                 step: Optional[str] = None,
+                                 index: Optional[Union[int, str]] = None):
+        """
+        Sets the length of bench wires.
+
+        Args:
+            length (float): The length in microns.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "bench_length", length, step=step, index=index)
+
     def task(self):
         return "rcx_bench"
 

siliconcompiler/tools/openroad/rcx_extract.py

@@ -1,3 +1,5 @@
+from typing import Optional, Union
+
 from siliconcompiler.tools.openroad import OpenROADTask
 
 
@@ -10,6 +12,18 @@ class ORXExtractTask(OpenROADTask):
 
         self.add_parameter("corner", "str", "Parasitic corner to generate RCX file for")
 
+    def set_openroad_rcxcorner(self, corner: str,
+                               step: Optional[str] = None, index: Optional[Union[int, str]] = None):
+        """
+        Sets the parasitic corner to generate the RCX file for.
+
+        Args:
+            corner (str): The parasitic corner name.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "corner", corner, step=step, index=index)
+
     def task(self):
         return "rcx_extract"
 

siliconcompiler/tools/openroad/rdlroute.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from siliconcompiler.tools.openroad import OpenROADTask
 
 
@@ -21,6 +23,18 @@ class RDLRouteTask(OpenROADTask):
             else:
                 self.add("var", "rdlroute", file, step=step, index=index)
 
+    def set_openroad_addfill(self, enable: bool,
+                             step: Optional[str] = None, index: Optional[str] = None):
+        """
+        Enables or disables adding fill to the design.
+
+        Args:
+            enable (bool): True to enable fill, False to disable.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "fin_add_fill", enable, step=step, index=index)
+
     def task(self):
         return "rdlroute"
 

siliconcompiler/tools/openroad/repair_design.py

@@ -1,3 +1,5 @@
+from typing import Optional, Union
+
 from siliconcompiler.tools.openroad._apr import APRTask
 from siliconcompiler.tools.openroad._apr import OpenROADSTAParameter, OpenROADRSZDRVParameter
 
@@ -20,6 +22,45 @@ class RepairDesignTask(APRTask, OpenROADSTAParameter, OpenROADRSZDRVParameter):
                            "true/false, when true enables adding buffers to the output ports",
                            defvalue=False)
 
+    def set_openroad_tieseparation(self, separation: float,
+                                   step: Optional[str] = None,
+                                   index: Optional[Union[int, str]] = None):
+        """
+        Sets the maximum distance between tie high/low cells.
+
+        Args:
+            separation (float): The separation distance in microns.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "ifp_tie_separation", separation, step=step, index=index)
+
+    def set_openroad_bufferinputs(self, enable: bool,
+                                  step: Optional[str] = None,
+                                  index: Optional[Union[int, str]] = None):
+        """
+        Enables or disables adding buffers to the input ports.
+
+        Args:
+            enable (bool): True to enable, False to disable.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "rsz_buffer_inputs", enable, step=step, index=index)
+
+    def set_openroad_bufferoutputs(self, enable: bool,
+                                   step: Optional[str] = None,
+                                   index: Optional[Union[int, str]] = None):
+        """
+        Enables or disables adding buffers to the output ports.
+
+        Args:
+            enable (bool): True to enable, False to disable.
+            step (str, optional): The specific step to apply this configuration to.
+            index (str, optional): The specific index to apply this configuration to.
+        """
+        self.set("var", "rsz_buffer_outputs", enable, step=step, index=index)
+
     def task(self):
         return "repair_design"