### Launching OpenROAD Interactive Mode (Setup) - Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Use these shell commands to navigate to the test directory and launch the OpenROAD tool in interactive mode for experimenting with setup violation fixing examples.

```shell
cd ../tools/OpenROAD/src/rsz/test/
openroad
```

--------------------------------

### Source Macro Halo Example Scripts and Place in OpenROAD Tcl

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Load helper and specific example Tcl scripts (`helpers.tcl`, `level3.tcl`) and then run global placement as a setup step for demonstrating macro placement with halo spacing.

```tcl
source helpers.tcl
source level3.tcl
global_placement
```

--------------------------------

### Setting up OpenROAD AutoTuner using Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/InstructionsForAutoTuner.md

Provides shell commands to execute the provided installation and setup scripts for the AutoTuner framework. The `installer.sh` script handles prerequisites, while `setup.sh` likely configures the environment, possibly activating a virtual environment.

```shell
# Install prerequisites
./tools/AutoTuner/installer.sh

# Start virtual environment
./tools/AutoTuner/setup.sh
```

--------------------------------

### Installing and Setting Up AutoTuner Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/tools/AutoTuner/README.md

These shell commands are used to install the necessary prerequisites and set up the virtual environment for AutoTuner. They utilize convenience scripts provided in the AutoTuner tools directory.

```Shell
# Install prerequisites
./tools/AutoTuner/installer.sh
```

```Shell
# Start virtual environment
./tools/AutoTuner/setup.sh
```

--------------------------------

### Cloning and Installing Dependencies OpenROAD Flow Scripts Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/BuildLocally.md

Clones the OpenROAD-flow-scripts repository recursively to fetch submodules, navigates into the newly created directory, and executes the setup script (`setup.sh`) with superuser privileges to install all necessary system and project dependencies. This step is required before building the tools.

```shell
git clone --recursive https://github.com/The-OpenROAD-Project/OpenROAD-flow-scripts
cd OpenROAD-flow-scripts
sudo ./setup.sh
```

--------------------------------

### Starting Interactive Docker Container for Pre-built Binaries - Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/BuildWithDocker.md

Starts an interactive (`-it`) Docker container based on the `ubuntu:22.04` image. This provides a shell environment inside the container where users can then follow instructions to install pre-built OpenROAD binaries.

```shell
docker run -it ubuntu:22.04
```

--------------------------------

### Launch OpenROAD for Tie Cell Example

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Navigate to the tie cell test directory and launch the OpenROAD tool in command-line mode to run the tie cell insertion example script.

```shell
cd ../tools/OpenROAD/src/ifp/test/
openroad
```

--------------------------------

### Cloning OpenROAD Flow Scripts Repository Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/BuildWithPrebuilt.md

This standard shell command uses 'git clone' to download the 'OpenROAD-flow-scripts' repository from GitHub. This repository contains examples and scripts necessary to verify the successful installation of the OpenROAD tools and run basic design flows.

```shell
git clone https://github.com/The-OpenROAD-Project/OpenROAD-flow-scripts.git
```

--------------------------------

### Install OpenROAD Docs Build Prerequisites (Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/README.md

This snippet provides the shell commands necessary to set up a Python virtual environment, activate it, and install the required dependencies for building the documentation using pip and the specified requirements file.

```shell
virtualenv .venv
```

```shell
source .venv/bin/activate
```

```shell
pip install -r requirements.txt
```

--------------------------------

### Launch OpenROAD GUI for Macro Placement Example

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Navigate to the global placement test directory and launch the OpenROAD tool in graphical user interface mode to visualize macro and standard cell placement.

```shell
cd ../tools/OpenROAD/src/gpl/test/
openroad -gui
```

--------------------------------

### Launch OpenROAD GUI for Macro Halo Example

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Navigate to the macro placement test directory and launch the OpenROAD tool in graphical user interface mode to visualize macro placement with and without halo spacing.

```shell
cd ../tools/OpenROAD/src/mpl/test
openroad -gui
```

--------------------------------

### Setup Design for Unbalanced CTS Example - OpenROAD TCL

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

These TCL commands source helper scripts, read libraries and lef, create a block with many instances (simulating sinks), define the STA network, create a clock, and set clock wire parasitics. This setup creates a scenario for demonstrating unbalanced and then balanced CTS.

```tcl
source "helpers.tcl"
source "cts-helpers.tcl"
read_liberty Nangate45/Nangate45_typ.lib
read_lef Nangate45/Nangate45.lef
set block [make_array 300 200000 200000 150]
sta::db_network_defined
create_clock -period 5 clk
set_wire_rc -clock -layer metal5
```

--------------------------------

### Setup Design and Report Timing - OpenROAD TCL

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

These TCL commands set up a design for setup timing analysis in OpenROAD. They define corners, read libraries and design files, create a clock, set wire parasitics, estimate parasitics post-placement, and generate an initial timing report.

```tcl
define_corners fast slow
read_liberty -corner slow Nangate45/Nangate45_slow.lib
read_liberty -corner fast Nangate45/Nangate45_fast.lib
read_lef Nangate45/Nangate45.lef
read_def repair_setup1.def
create_clock -period 0.3 clk
set_wire_rc -layer metal3
estimate_parasitics -placement
report_checks -fields input -digits 3
```

--------------------------------

### Launch OpenROAD GUI for Repair Design Example

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Navigate to the resizer test directory and launch the OpenROAD tool in graphical user interface mode to demonstrate and visualize the `repair_design` command's effects.

```shell
cd ../tools/OpenROAD/src/rsz/test/
openroad -gui
```

--------------------------------

### Launch OpenROAD GUI for Tapcell Example

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Navigate to the tap cell test directory and launch the OpenROAD tool in graphical user interface mode to visually inspect tap cell insertion.

```shell
cd ../tools/OpenROAD/src/tap/test/
openroad -gui
```

--------------------------------

### Reporting Setup Timing After Repair - OpenROAD TCL

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Use this TCL command to generate a detailed timing report focusing on setup paths after running the `repair_timing -setup` command. It helps verify if violations were fixed.

```tcl
report_checks -fields input -digits 3
```

--------------------------------

### Verifying OpenROAD Tools and Flow inside Docker - Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/BuildWithDocker.md

These commands are executed *inside* the previously started Docker container. They source the environment setup script, check `yosys` and `openroad` versions using their help flags, navigate to the `flow` directory, run the `make` command to build/verify the flow setup, and finally exit the container.

```shell
source ./env.sh
yosys -help
openroad -help
cd flow
make
exit
```

--------------------------------

### Installing OpenROAD Debian Package Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/BuildWithPrebuilt.md

This shell command uses the 'sudo apt install' command to install the OpenROAD .deb package downloaded in a previous step. It requires administrative privileges and the path to the downloaded Debian package file. This command integrates the OpenROAD executable and its dependencies into the system using the standard package manager.

```shell
sudo apt install ./openroad_2.0_amd64-ubuntu20.04.deb
```

--------------------------------

### Installing Build Dependencies (Bash)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/BuildWithWSL.md

Installs necessary development tools and Python environment components (build-essential, python3, python3-venv, python3-pip, make) within the WSL Linux distribution. Requires root privileges (`sudo`). Updates and upgrades existing packages before installation.

```Bash
sudo apt-get update; sudo apt-get upgrade; sudo apt install -y build-essential python3 python3-venv python3-pip make
```

--------------------------------

### Verifying OpenROAD and Yosys Installation Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/BuildWithPrebuilt.md

This block of shell commands is used to verify that OpenROAD and Yosys have been correctly installed and are accessible in the system's PATH. It sets environment variables, optionally updates LD_LIBRARY_PATH for KLayout if built from source, checks tool availability using '-help', navigates to the 'flow' directory, and runs 'make' commands to execute sample design flows.

```shell
# these variables are used in flow/Makefile. Do make sure the yosys path is sourced.
export OPENROAD_EXE=$(command -v openroad)
export YOSYS_EXE=$(command -v yosys)

# only if KLayout is built from source
export LD_LIBRARY_PATH="<klayout_location>/bin:$PATH"

yosys -help
openroad -help
cd flow
make
make gui_final
```

--------------------------------

### Verifying Docker Installation (Bash)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/BuildWithWSL.md

Executes the `hello-world` Docker container to confirm that the Docker daemon is accessible and functioning correctly from within the WSL environment. Outputs a standard success message if integration is successful.

```Bash
docker run hello-world
```

--------------------------------

### Launching OpenROAD GUI (Simple CTS) - Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Use these shell commands to navigate to the CTS test directory and launch the OpenROAD tool in GUI mode for exploring simple clock tree synthesis examples.

```shell
cd ../tools/OpenROAD/src/cts/test/
openroad -gui
```

--------------------------------

### Launching OpenROAD GUI (Balanced CTS) - Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Use these shell commands to navigate to the CTS test directory and launch the OpenROAD tool in GUI mode for exploring balanced clock tree synthesis examples.

```shell
cd ../tools/OpenROAD/src/cts/test/
openroad -gui
```

--------------------------------

### Launching OpenROAD GUI for GRT Example (shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

This command sequence navigates to the Global Router test directory within the OpenROAD source tree and launches the OpenROAD tool with the graphical user interface enabled, which is useful for visualizing routing results and debugging congestion issues.

```shell
cd ../tools/OpenROAD/src/grt/test/
openroad -gui
```

--------------------------------

### Launching GUI for DRC Tutorial - Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Changes the current directory to the specific tutorial directory for Design Rule Checking (DRC) examples and then launches the OpenROAD GUI directly using the `openroad -gui` command. This prepares the environment and loads a specific design context used in the subsequent DRC demonstration steps. Required: OpenROAD flow scripts downloaded and environment sourced.

```shell
cd ./flow/tutorials/scripts/drt/
openroad -gui
```

--------------------------------

### Building OpenROAD-flow-scripts for Local Installation

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/FAQS.md

Command to rebuild OpenROAD-flow-scripts with a clean build for local installations, requiring the --local flag. This tailors the build process for a standard local environment.

```shell
./build_openroad.sh --local --clean
```

--------------------------------

### Starting Docker Container for Build Verification - Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/BuildWithDocker.md

Runs a Docker container from the `openroad/flow-ubuntu22.04-builder` image ephemerally (`--rm`) in interactive mode (`-it`). It maps the local `flow` directory into the container and sets the user ID to match the host user for file permission consistency. This container is used to verify the installed tools and run the flow.

```shell
docker run --rm -it -u $(id -u ${USER}):$(id -g ${USER}) -v $(pwd)/flow:/OpenROAD-flow-scripts/flow openroad/flow-ubuntu22.04-builder
```

--------------------------------

### Example Invocation of KLayout File Generation Script (Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/flow/scripts/klayout/README.md

Shows a practical example of executing the `gen_klayout_files.sh` script using hypothetical input files (`process.tf`, `process.layermap`, `adv_process.lef`) and specifying technology details ('adv_process', 'Really advanced process') and output file paths (`output.lyp`, `output.lyt`). It also includes an example of using a custom layer name mapper file (`AdvProcessLayerNameMapper.rb`).

```Shell
gen_klayout_files.sh -v process.tf -l process.layermap -d adv_process.lef \
                     -n adv_process -d "Really advanced process" -p output.lyp \
                     -o output.lyt -m AdvProcessLayerNameMapper.rb
```

--------------------------------

### Build OpenROAD Docs HTML Output (Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/README.md

This command executes the Makefile target 'html', which compiles the documentation source files into HTML format. This step requires the build prerequisites to be installed and the virtual environment to be active.

```shell
make html
```

--------------------------------

### Launch OpenROAD and Run Repair Timing Example

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Navigate to the appropriate test directory, launch the OpenROAD tool in command-line mode, and source the Tcl script (`gcd_sky130hd_fast_slow.tcl`) which demonstrates timing repair (`repair_timing`) considering multiple process corners (fast and slow).

```shell
cd ../../test/
openroad
source gcd_sky130hd_fast_slow.tcl
```

--------------------------------

### Verifying OpenROAD and Flow Script Installation Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/BuildLocally.md

Sources the environment script (`env.sh`) to add the built OpenROAD and Yosys binaries to the system's PATH, verifies that `yosys` and `openroad` commands are accessible by running their help options, changes the current directory to the `flow` subdirectory, and runs the default `make` target to execute a sample RTL-to-GDSII flow (e.g., for the `gcd` design with `nangate45` PDK). This confirms the tools are correctly installed and configured.

```shell
source ./env.sh
yosys -help
openroad -help
cd flow
make
```

--------------------------------

### Launching OpenROAD GUI (Hold) - Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Use these shell commands to navigate to the test directory and launch the OpenROAD tool in GUI mode for interactive hold violation fixing examples.

```shell
cd ../tools/OpenROAD/src/rsz/test/
openroad -gui
```

--------------------------------

### Loading Files and Running Detail Routing (Tcl)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Details the Tcl commands to load various design files (LEFs, DEF, routing guides), set the number of threads for parallel processing, execute the `detailed_route` command with options for output reports, and finally save the routed database.

```tcl
read_lef Nangate45/Nangate45_tech.lef
read_lef Nangate45/Nangate45_stdcell.lef
read_def gcd_nangate45_preroute.def
read_guides gcd_nangate45.route_guide
set_thread_count [expr [exec getconf _NPROCESSORS_ONLN] / 4]
detailed_route -output_drc results/gcd_nangate45.output.drc.rpt \
               -output_maze results/gcd_nangate45.output.maze.log \
               -verbose 1
write_db gcd_nangate45.odb
```

--------------------------------

### Displaying Build Help for OpenROAD Shell Script

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/index.md

This command executes the main build script for OpenROAD Flow Scripts with the `--help` flag. It displays available command-line options and usage instructions for customizing the build process, such as choosing installation method, build threads, specific branches/repos, and compilation flags.

```shell
./build_openroad.sh --help
```

--------------------------------

### Launching OpenROAD CLI for RCX Example (shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

This command sequence navigates to the OpenRCX test directory within the OpenROAD source tree and launches the OpenROAD tool in command-line interface mode, preparing the environment to execute parasitic extraction test scripts.

```shell
cd ../tools/OpenROAD/src/rcx/test/
openroad
```

--------------------------------

### Fixing Setup Timing Violations - OpenROAD TCL

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

This TCL command attempts to automatically repair setup timing violations in the current design using OpenROAD's resizer tool.

```tcl
repair_timing -setup
```

--------------------------------

### Running OpenROAD Autotuner Smoke Tests (Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/tools/AutoTuner/README.md

These shell commands execute the setup script and a series of Python-based smoke tests for the OpenROAD Autotuner testing framework. They verify basic functionality of sweep, tune, and sample iteration processes. Requires the virtual environment to be activated or configured correctly beforehand.

```Shell
./tools/AutoTuner/setup.sh
python3 ./tools/AutoTuner/test/smoke_test_sweep.py
python3 ./tools/AutoTuner/test/smoke_test_tune.py
python3 ./tools/AutoTuner/test/smoke_test_sample_iteration.py
```

--------------------------------

### Building Example Design with Docker (Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/DockerShell.md

This snippet first changes the directory to the `flow` directory within the project, then uses `util/docker_shell` to run `make` (to build the design) and `make gui_final` (to launch the final GUI view) inside the specified Docker container.

```Shell
cd flow
util/docker_shell make
util/docker_shell make gui_final
```

--------------------------------

### Source Macro Placement Example Script in OpenROAD Tcl

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Execute the Tcl script `macro01.tcl` within the OpenROAD GUI's Tcl console to perform and visualize an initial macro and standard cell placement with a default density.

```tcl
source macro01.tcl
```

--------------------------------

### Setup and Analyze Timing Violations in OpenROAD Tcl

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Load helper scripts and libraries, create a test design with high fanout, define clock and RC parameters, estimate parasitics, set a maximum transition time constraint, and report the initial count of maximum slew violations using Tcl commands.

```tcl
source "helpers.tcl"
source "hi_fanout.tcl"
read_liberty Nangate45/Nangate45_typ.lib
read_lef Nangate45/Nangate45.lef
set def_file [make_result_file "repair_slew1.def"]
write_hi_fanout_def $def_file 30
read_def $def_file

create_clock -period 1 clk1
set_wire_rc -layer metal3

estimate_parasitics -placement
set_max_transition .05 [current_design]

puts "Found [sta::max_slew_violation_count] violations"
```

--------------------------------

### Building OpenROAD-flow-scripts for WSL/Docker

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/FAQS.md

Command to rebuild OpenROAD-flow-scripts with a clean build specifically for installations running within a WSL or Docker environment. This ensures dependencies are correctly compiled.

```shell
./build_openroad.sh --clean
```

--------------------------------

### Setup Design, Global Route, and Report Hold - OpenROAD TCL

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

These TCL commands set up a design, perform global routing, estimate parasitics, and report the worst hold slack. This prepares the design state for demonstrating hold violation fixing.

```tcl
source helpers.tcl
read_liberty sky130hd/sky130hd_tt.lib
read_lef sky130hd/sky130hd.tlef
read_lef sky130hd/sky130hd_std_cell.lef
read_def repair_hold10.def
create_clock -period 2 clk
set_propagated_clock clk
set_wire_rc -resistance 0.0001 -capacitance 0.00001
set_routing_layers -signal met1-met5
global_route
estimate_parasitics -global_routing
report_worst_slack -min
```

--------------------------------

### Adjusting Clock Period and Retrying Setup Fix - OpenROAD TCL

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

These commands modify the clock period to relax timing constraints and then re-run the setup timing repair process. This demonstrates how adjusting design parameters can impact fixability.

```tcl
create_clock -period 0.9 clk
repair_timing -setup
```

--------------------------------

### Running Global Routing Congestion Example (tcl)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

This Tcl command sources and executes the `congestion5.tcl` script within the running OpenROAD GUI instance. This particular script is designed to run the global router on a design that will intentionally fail due to high congestion, allowing users to observe the error and visualize the congestion in the GUI.

```tcl
source congestion5.tcl
```

--------------------------------

### Running OpenRCX Example Script (tcl)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

This Tcl command sources and executes the `45_gcd.tcl` script within the running OpenROAD CLI instance. The script typically contains commands to load a design, configure extraction parameters, run the OpenRCX tool, and generate output files like SPEF.

```tcl
source 45_gcd.tcl
```

--------------------------------

### Source Tapcell Example Script in OpenROAD Tcl

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Execute the Tcl script specific to the GCD design and Nangate45 library within the OpenROAD GUI's Tcl console to perform and visualize tap cell insertion.

```tcl
source gcd_nangate45.tcl
```

--------------------------------

### Launching OpenROAD GUI via Makefile - Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Executes the `make gui_final` target in the OpenROAD flow scripts Makefile. This command typically builds or prepares the environment and launches the OpenROAD GUI, loading the final design database for visualization and inspection after a complete flow run. Required: OpenROAD flow environment setup with Makefile.

```shell
make gui_final
```

--------------------------------

### Example Input Configuration for OpenROAD AutoTuner JSON

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/InstructionsForAutoTuner.md

Illustrates the minimal JSON structure required to define parameters for AutoTuner. It specifies parameter names, their data types ('float' or 'int'), the minimum and maximum range for sweeping/tuning, and an optional step value (step 0 for continuous float or constant int).

```json
{
    "_SDC_FILE_PATH": "constraint.sdc",
    "_SDC_CLK_PERIOD": {
        "type": "float",
        "minmax": [
            1.0,
            3.7439
        ],
        "step": 0
    },
    "CORE_MARGIN": {
        "type": "int",
        "minmax": [
            2,
            2
        ],
        "step": 0
    },
}
```

--------------------------------

### Defining AutoTuner Parameters JSON

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/tools/AutoTuner/README.md

This JSON snippet shows a minimal example of the configuration structure used by AutoTuner to define parameters for sweeping or tuning. It specifies parameter names, their data types ('float' or 'int'), minimum and maximum values ('minmax'), and step size.

```JSON
{
    "_SDC_FILE_PATH": "constraint.sdc",
    "_SDC_CLK_PERIOD": {
        "type": "float",
        "minmax": [
            1.0,
            3.7439
        ],
        "step": 0
    },
    "CORE_MARGIN": {
        "type": "int",
        "minmax": [
            2,
            2
        ],
        "step": 0
    }
}
```

--------------------------------

### Verilog Netlist Demonstrating Tie High/Low

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Example Verilog code snippet showing instances of an AND gate where one input (`A2`) is explicitly tied to logic 0 (`1'b0`) or logic 1 (`1'b1`). These connections are candidates for replacement by tie cells during physical design.

```verilog
AND2_X1 u2 (.A1(r1q), .A2(1'b0), .ZN(u2z0));
AND2_X1 u3 (.A1(u1z), .A2(1'b1), .ZN(u2z1));
```

--------------------------------

### Starting Docker Container for GUI Support (Ubuntu/Debian) - Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/BuildWithDocker.md

Runs a Docker container with specific volume mounts (`-v`) and environment variables (`-e`) required to forward the graphical display from the container to the host X server on Ubuntu/Debian systems. This allows users to run GUI-enabled OpenROAD tools inside Docker.

```shell
docker run --rm -it \
           -u $(id -u ${USER}):$(id -g ${USER}) \
           -v $(pwd)/flow:/OpenROAD-flow-scripts/flow \
           -e DISPLAY=${DISPLAY} \
           -v /tmp/.X11-unix:/tmp/.X11-unix \
           -v ${HOME}/.Xauthority:/.Xauthority \
           --network host \
           --security-opt seccomp=unconfined \
           openroad/flow-$OS_NAME-builder
```

--------------------------------

### Source Tie Cell Example Script in OpenROAD Tcl

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Execute the Tcl script `tiecells.tcl` within the OpenROAD Tcl console to perform tie cell insertion based on the design's netlist requirements.

```tcl
source tiecells.tcl
```

--------------------------------

### Report Timing Slack and TNS in OpenROAD Tcl

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Print the worst negative slack (setup, `-min`), worst positive slack (hold, `-max`), and total negative slack (`tns`) for the design with a specified precision (`-digits 3`) after timing analysis and/or repair.

```tcl
report_worst_slack -min -digits 3
report_worst_slack -max -digits 3
report_tns -digits 3
```

--------------------------------

### Creating and Updating New Development Branch from Master

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/FAQS.md

Git command sequence to create a new development branch, switch to it, and immediately merge the latest changes from the master branch. This is useful for starting new features based on the current main branch state.

```shell
git checkout -b <BRANCH> && git merge master
```

--------------------------------

### Using Prebuilt Docker Image with Custom Paths (Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/DockerShell.md

This snippet shows how to use a prebuilt Docker image (`openroad_prebuilt_image`) specified via `OR_IMAGE` and also set custom environment variables, like `YOSYS_EXE`, which might be necessary for tools within that specific image setup. It then executes the `make` command within this configured environment.

```Shell
OR_IMAGE=openroad_prebuilt_image YOSYS_EXE=/oss-cad-suite/bin/yosys util/docker_shell make
```

--------------------------------

### Starting Docker Container for GUI Support (Mac OS X) - Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/BuildWithDocker.md

Runs a Docker container (`<IMAGE_NAME>`) configured for GUI support on Mac OS X, based on external tutorial instructions. It sets the `DISPLAY` environment variable to point to a specific IP and enables host networking and privileged mode.

```shell
docker run --rm -it -e DISPLAY=<IP_LIKE_FROM_TUTORIAL>:0 --network host --privileged <IMAGE_NAME>
```

--------------------------------

### Running Autotuner Testing Framework (Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/InstructionsForAutoTuner.md

Provides the command-line instructions to set up the Autotuner testing environment and execute various smoke tests (sweep, tune, sample iteration). Requires the virtual environment to be previously set up at `./tools/AutoTuner/autotuner_env`.

```Shell
./tools/AutoTuner/setup.sh
python3 ./tools/AutoTuner/test/smoke_test_sweep.py
python3 ./tools/AutoTuner/test/smoke_test_tune.py
python3 ./tools/AutoTuner/test/smoke_test_sample_iteration.py
```

--------------------------------

### Building OpenROAD Locally Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/BuildLocally.md

Executes the `build_openroad.sh` script located in the project root directory with the `--local` flag. This command compiles the OpenROAD tool itself based on the local configuration and dependencies installed in the previous step. A log file named `build_openroad.log` is generated.

```shell
./build_openroad.sh --local
```

--------------------------------

### Configuring Design Variables in config.mk Shell Script

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/contrib/PlatformBringUp.md

An example `config.mk` file snippet defining key variables for a specific design within a platform using shell export commands. It sets the design name, target platform, paths to source Verilog and SDC files, and physical design parameters like core utilization, aspect ratio, margin, and place density.

```shell
export DESIGN_NAME     = gcd
export PLATFORM        = sky130hd

export VERILOG_FILES = $(sort $(wildcard ./designs/src/$(DESIGN_NAME)/*.v))

export SDC_FILE = ./designs/$(PLATFORM)/$(DESIGN_NAME)/constraint.sdc

export CORE_UTILIZATION  = 30
export CORE_ASPECT_RATIO = 1
export CORE_MARGIN       = 2
export PLACE_DENSITY     = 0.70
```

--------------------------------

### Launching OpenROAD GUI Directly - Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Executes the `openroad -gui` command directly from the shell, launching the OpenROAD tool in its graphical mode. This is used here to reload the GUI, typically after modifying design files like the DEF to apply fixes or load a different design state. Required: OpenROAD tool installed and in the system's PATH.

```shell
openroad -gui
```

--------------------------------

### Instantiating Generic Clock Gate in User Verilog Design

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/contrib/PlatformBringUp.md

An example Verilog snippet illustrating how a user design (`buffer`) instantiates the generic `OPENROAD_CLKGATE` module. It connects the main clock (`clk`) and an enable signal (`enable`) to generate a gated clock (`gck`), which is then used to control the clocking of sequential logic (e.g., a register).

```verilog
// This is not a platform file, this is an example user design

module buffer (clk, enable, in, out);

input        clk, enable;
input  [7:0] in,
output [7:0] out

reg  [15:0] buffer_reg;
wire        gck; // Gated clock

OPENROAD_CLKGATE clkgate (.CK(clk), .E(enable), .GCK(gck));

// Buffer does not change if enable is low
always @(posedge gck) begin
  buffer_reg[15:8] <= in;
  buffer_reg[ 7:0] <= buffer_reg[15:8];
end

assign out = buffer_reg[ 7:0];

```

--------------------------------

### Example DEF Placement Fix - Text

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

This snippet presents modified lines from a Design Exchange Format (DEF) file showing the correction for the previous placement violation. The coordinates for cell `output53` have been changed to a unique location, resolving the overlap and the resulting 'short' DRC violation. This is file content, not executable code. Required: Understanding of DEF file structure.

```text
- output51 sky130_fd_sc_hd__clkbuf_1 + PLACED ( 267260 136000 ) N ;
- output53 sky130_fd_sc_hd__clkbuf_1 + PLACED ( 124660 266560 ) N ;
```

--------------------------------

### Example DEF Placement Violation - Text

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

This snippet shows lines from a Design Exchange Format (DEF) file illustrating a common placement-related Design Rule Check (DRC) violation. It demonstrates two standard cells (`output51` and `output53`) being placed at the exact same physical coordinates, which typically results in a 'short' violation. This is file content, not executable code. Required: Understanding of DEF file structure.

```text
- output51 sky130_fd_sc_hd__clkbuf_1 + PLACED ( 267260 136000 ) N ;
- output53 sky130_fd_sc_hd__clkbuf_1 + PLACED ( 267260 136000 ) N ;
```

--------------------------------

### Launching OpenROAD GUI for Detail Routing (Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Provides the shell commands to navigate to the detail routing test directory and launch the OpenROAD tool in graphical user interface mode, preparing the environment for interactive detail routing execution.

```shell
cd ../tools/OpenROAD/src/drt/test/
openroad -gui
```

--------------------------------

### Launching OpenROAD GUI for Metal Fill (Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Provides the shell commands to navigate to the metal fill tutorial directory and launch the OpenROAD tool in graphical user interface mode, preparing the environment for performing and viewing metal fill operations.

```shell
cd flow/tutorials/scripts/metal_fill
openroad -gui
```

--------------------------------

### Launching OpenROAD GUI for Filler Placement (Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Provides the shell commands to navigate to the relevant test directory and launch the OpenROAD tool in graphical user interface (GUI) mode. This prepares the environment for interactive Tcl command execution related to filler cell insertion.

```shell
cd ../tools/OpenROAD/src/grt/test/
openroad -gui
```

--------------------------------

### Run OpenROAD Flow with Specific Configuration

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Execute the `make` command to trigger the OpenROAD flow for a design (e.g., 'ibex'), explicitly specifying a configuration file (`config.mk`) that defines parameters like placement density and core utilization.

```shell
make DESIGN_CONFIG=./designs/sky130hd/ibex/config.mk
```

--------------------------------

### Running Placement Flow and GUI - OpenROAD-flow-scripts Make

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/flow/designs/asap7/minimal/README.md

Executes the full placement flow, including cleaning previous results, performing placement, and opening the OpenROAD GUI to visualize the placement results. Uses the same design configuration and source files.

```Makefile
make DESIGN_CONFIG=designs/asap7/minimal/config.mk DESIGN_NAME=aes_cipher_top VERILOG_FILES="$(ls designs/src/aes/*.v | xargs)" clean_place place gui_place
```

--------------------------------

### Launching OpenROAD for CTS Reporting (Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Provides the shell commands to navigate to the CTS test directory and launch the OpenROAD tool. It then sources a Tcl script (`post_cts_opt.tcl`) and runs the `report_cts` command to display clock tree synthesis metrics.

```shell
cd ../tools/OpenROAD/src/cts/test/
openroad
source post_cts_opt.tcl
report_cts
```

--------------------------------

### Cleaning All Flow Results (Make/Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Deletes all generated intermediate and final files for a specific design configuration. This command is useful for cleaning up previous runs, especially after errors, to ensure a fresh start for the flow execution.

```shell
make clean_all DESIGN_CONFIG=./designs/sky130hd/ibex/config.mk
```

--------------------------------

### Running Floorplan Flow and GUI - OpenROAD-flow-scripts Make

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/flow/designs/asap7/minimal/README.md

Executes the full floorplan flow, including cleaning previous results, performing floorplanning, and opening the OpenROAD GUI to visualize the floorplan. Uses the same design configuration and source files.

```Makefile
make DESIGN_CONFIG=designs/asap7/minimal/config.mk DESIGN_NAME=aes_cipher_top VERILOG_FILES="$(ls designs/src/aes/*.v | xargs)" clean_floorplan floorplan gui_floorplan
```

--------------------------------

### Launching OpenROAD GUI for Global Routing (Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Provides the shell commands to change the directory to the global routing test location and launch the OpenROAD tool in GUI mode. This sets up the interactive environment for running global routing commands.

```shell
cd ../tools/OpenROAD/src/grt/test/
openroad -gui
```

--------------------------------

### Loading Routed Design Database for Metal Fill (Tcl)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Shows the Tcl commands executed within the OpenROAD GUI to source a helper script and load the design database (`.odb`) from the previous routing step. This loaded database serves as the input for the metal fill process.

```tcl
source "helpers.tcl"
read_db ./5_route.odb
```

--------------------------------

### Launch OpenROAD GUI from Flow Directory

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Launch the OpenROAD tool in graphical user interface mode directly from the flow directory to view the results of a previous flow run, such as a placement DEF file.

```shell
openroad -gui
```

--------------------------------

### Viewing Design Configuration File (Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Uses the less command to display the contents of the config.mk file specific to the ibex design under the designs/sky130hd directory. This file contains variables like PLATFORM, DESIGN_NAME, VERILOG_FILES, and constraints specific to the design.

```Shell
less ./designs/sky130hd/ibex/config.mk
```

--------------------------------

### Running OpenROAD Flow (Make/Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Executes the full automated RTL-to-GDS flow using the Make build system. It requires specifying the design configuration file, which defines the target design (e.g., 'ibex') and platform (e.g., 'sky130hd'). This command initiates the sequence of tools from synthesis to GDSII output.

```shell
make DESIGN_CONFIG=./designs/sky130hd/ibex/config.mk
```

--------------------------------

### Loading Design Files for Filler Placement (Tcl)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Shows Tcl commands executed within the OpenROAD GUI's Tcl console to load the necessary library definitions (`read_lef`) and the current design state (`read_def`) before performing filler cell insertion.

```tcl
source "helpers.tcl"
read_lef "Nangate45/Nangate45.lef"
read_def "gcd.def"
```

--------------------------------

### Opening Synthesis GUI - OpenROAD-flow-scripts Make

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/flow/designs/asap7/minimal/README.md

Invokes the `gui_synth` make target to launch the OpenROAD GUI after the synthesis stage has completed. This allows for visual inspection of the synthesized netlist and initial layout.

```Makefile
gui_synth
```

--------------------------------

### Running Global Routing Script (Tcl)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Shows the Tcl command used in the OpenROAD GUI to source and execute a script (`gcd.tcl`) containing the specific commands and settings required to perform the global routing step for the current design.

```tcl
source gcd.tcl
```

--------------------------------

### Building OpenROAD and All ORFS Flows with Bazel Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/BuildLocally.md

Navigates to the `flow` directory, then builds the optimized OpenROAD binary using Bazel within the OpenROAD source directory. Upon successful build, it uses `bazelisk` to build all available ORFS design targets (`...`) using the newly built OpenROAD binary. This runs a comprehensive set of flows defined in the Bazel build files.

```shell
cd flow
(cd ../tools/OpenROAD && bazel build :openroad -c opt) && bazelisk build ...
```

--------------------------------

### Executing OpenROAD AutoTuner in Tune Mode using Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/InstructionsForAutoTuner.md

Demonstrates the shell command to run the `openroad_autotuner` script in 'tune' mode. It requires specifying the design, platform, and configuration JSON file, along with the `--samples` argument to indicate the number of tuning trials.

```shell
openroad_autotuner --design gcd --platform sky130hd \
                       --config ../../flow/designs/sky130hd/gcd/autotuner.json \
                       tune --samples 5
```

--------------------------------

### Creating Design Directory and Files using Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/contrib/PlatformBringUp.md

Employs `mkdir -p` to create the directory structure for a specific design (e.g., `gcd`) under the new platform's designs directory. It then uses `touch` to create empty `config.mk` and `constraint.sdc` files, which are essential for configuring the design run for this platform.

```shell
mkdir -p flow/designs/MyNewPlatform/gcd
touch flow/designs/MyNewPlatform/gcd/config.mk
touch flow/designs/MyNewPlatform/gcd/constraint.sdc
```

--------------------------------

### Building OpenROAD and Specific ORFS Flow with Bazel Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/BuildLocally.md

Navigates to the `flow` directory, then builds the optimized OpenROAD binary using Bazel within the OpenROAD source directory. Upon successful build, it uses `bazelisk` to build a specific ORFS design target (`designs/asap7/gcd:gcd_floorplan`) using the newly built OpenROAD binary. This demonstrates running a single flow target with the Bazel build system.

```shell
cd flow
(cd ../tools/OpenROAD && bazel build :openroad -c opt) && bazelisk build designs/asap7/gcd:gcd_floorplan
```

--------------------------------

### Viewing Platform Configuration File (Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Uses the less command to display the contents of the config.mk file located in the platforms/sky130hd directory. This file contains default configuration variables for the sky130hd technology platform used by the flow.

```Shell
less ./platforms/sky130hd/config.mk
```

--------------------------------

### Viewing Design Timing Constraints File (Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Uses the less command to display the contents of the constraint.sdc file for the ibex design. This file contains timing constraints, typically defined using Tcl commands, required for static timing analysis during the flow.

```Shell
less ./designs/sky130hd/ibex/constraint.sdc
```

--------------------------------

### Running Synthesis Flow and GUI - OpenROAD-flow-scripts Make

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/flow/designs/asap7/minimal/README.md

Executes the full synthesis flow for a specified design, including cleaning previous results, running the synthesis process, and opening the OpenROAD GUI to visualize the synthesis output. This command is useful for initial design exploration with a minimal configuration.

```Makefile
make DESIGN_CONFIG=designs/asap7/minimal/config.mk DESIGN_NAME=aes_cipher_top VERILOG_FILES="$(ls designs/src/aes/*.v | xargs)" clean_synth synth gui_synth
```

--------------------------------

### Running Density Fill Command (Tcl)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Illustrates the Tcl command to execute the `density_fill` operation. It specifies the path to the JSON configuration file (`fill.json`) containing the rules that govern the placement and density of the inserted metal fill shapes.

```tcl
density_fill -rules ../../../platforms/sky130hd/fill.json
```

--------------------------------

### Running AutoTuner in Tune Mode Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/tools/AutoTuner/README.md

This command demonstrates how to execute AutoTuner in 'tune' mode. It specifies the design, platform, and configuration file, along with the number of samples to use for the tuning process.

```Shell
openroad_autotuner --design gcd --platform sky130hd \
                       --config ../../flow/designs/sky130hd/gcd/autotuner.json \
                       tune --samples 5
```

--------------------------------

### Launching OpenROAD for Antenna Checking (Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Provides the shell commands to change the current directory to the antenna checking test case location and launch the OpenROAD tool in batch mode. This sets up the environment for running antenna checks.

```shell
cd ../tools/OpenROAD/src/ant/test/
openroad
```

--------------------------------

### Load LEF and DEF Files in OpenROAD Tcl

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Load technology library exchange format (LEF) files and a design exchange format (DEF) file into OpenROAD to display the design's floorplan and placement.

```tcl
read_lef ./platforms/sky130hd/lef/sky130_fd_sc_hd.tlef
read_lef ./platforms/sky130hd/lef/sky130_fd_sc_hd_merged.lef
read_def ./results/sky130hd/ibex/base/3_place.def
```

--------------------------------

### Creating Technology File Directories using Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/contrib/PlatformBringUp.md

Uses the `mkdir` command to create dedicated subdirectories within the platform directory for storing the standard cell library files: timing data (`lib`), physical layout data (`lef`), and graphic design system data (`gds`). This organizational structure is recommended practice.

```shell
mdkir flow/platforms/MyNewPlatform/lib
mdkir flow/platforms/MyNewPlatform/lef
mdkir flow/platforms/MyNewPlatform/gds
```

--------------------------------

### Configuring and Running Filler Placement (Tcl)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Illustrates the Tcl commands used to define a list of master cell names (`set filler_master`) suitable for filling gaps and then execute the `filler_placement` command using this list to insert filler cells into the layout.

```tcl
set filler_master [list FILLCELL_X1 FILLCELL_X2 FILLCELL_X4 FILLCELL_X8 FILLCELL_X16]
filler_placement $filler_master
```

--------------------------------

### Performing Simple Clock Tree Synthesis - OpenROAD TCL

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

These TCL commands set up a simple design and run the clock tree synthesis process. They read libraries and def, create a clock, set clock wire parasitics, and execute CTS with specified buffer and wire parameters.

```tcl
read_lef Nangate45/Nangate45.lef
read_liberty Nangate45/Nangate45_typ.lib
read_def "16sinks.def"
create_clock -period 5 clk
set_wire_rc -clock -layer metal3
clock_tree_synthesis -root_buf CLKBUF_X3 \
                     -buf_list CLKBUF_X3 \
                     -wire_unit 20
```

--------------------------------

### Loading Files and Running Antenna Check (Tcl)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Shows the Tcl commands to load library and design files (`read_lef`, `read_def`), execute the `check_antennas` command to find violations, print the total violation count, and check if a specific net (`net50`) has violations.

```tcl
read_lef ant_check.lef
read_def ant_check.def

check_antennas -verbose
puts "violation count = [ant::antenna_violation_count]"

# check if net50 has a violation
set net "net50"
puts "Net $net violations: [ant::check_net_violation $net]"
```

--------------------------------

### Running OpenROAD Flow and Launching GUI (Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/tools/codespace/README.md

This sequence of shell commands is used within the Codespace terminal to navigate to the flow directory, set up the environment by sourcing the 'env.sh' script, execute the main build process ('make'), and finally launch the OpenROAD GUI for the resulting design ('make gui_final'). This serves as a test to ensure the ORFS flow and GUI access are functioning correctly within the Codespace.

```Shell
cd /OpenROAD-flow-scripts/flow
source ../env.sh
make
make gui_final
```

--------------------------------

### Listing Flow Directory Contents (Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Displays the top-level directories and files within the 'flow' directory of OpenROAD-flow-scripts. This helps users understand the structure where flow components, designs, platforms, and output artifacts are organized.

```shell
ls
```

--------------------------------

### Configure Design Utilization and Density (Makefile/Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Set environment variables or Makefile variables (`CORE_UTILIZATION`, `PLACE_DENSITY_LB_ADDON`) within a shell or configuration file to influence the placement density calculation and target utilization during the OpenROAD flow run.

```shell
export CORE_UTILIZATION = 40
export PLACE_DENSITY_LB_ADDON = 0.1
```

--------------------------------

### Listing Design Log Files (Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

Lists the log files generated by each stage of the OpenROAD flow for a specific design run. Examining these logs is essential for monitoring progress, debugging failures, and understanding the output of individual flow steps.

```shell
ls logs/sky130hd/ibex/base/
```

--------------------------------

### Launching OpenROAD Flow Scripts Docker Container (Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/tutorials/FlowTutorial.md

This command launches the OpenROAD-flow-scripts Docker container, mapping the local ./flow directory to /OpenROAD-flow-scripts/flow inside the container. It runs interactively (-it), removes the container on exit (--rm), and sets the user/group ID inside the container to match the host user.

```Shell
docker run --rm -it -u $(id -u ${USER}):$(id -g ${USER}) -v $(pwd)/flow:/OpenROAD-flow-scripts/flow openroad/flow-ubuntu22.04-builder
```

--------------------------------

### Generating Plots from OpenROAD AutoTuner Results using Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/InstructionsForAutoTuner.md

Provides the shell command to execute a Python utility script (`utils/plot.py`) for visualizing AutoTuner experiment results. The script takes the directory containing the results as an argument, allowing users to analyze metrics like QoR, runtime, clock period, or worst slack.

```shell
python3 utils/plot.py --results_dir <your-autotuner-result-path>
```

--------------------------------

### Usage of KLayout File Generation Shell Script (Shell)

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/flow/scripts/klayout/README.md

Documents the command-line arguments and syntax for the `gen_klayout_files.sh` script, which is the main driver for generating KLayout technology and layer properties files. It lists required inputs like Virtuoso tech file, layer map, tech LEF, technology name, description, and output paths for the KLayout files, along with optional arguments like a custom layer name mapper and help flag.

```Shell
Usage: gen_klayout_files.sh -v <virtuoso_tech_file> -l <virtuoso_layer_map>
                            -t <tech_lef> -n <tech_name>
                            -d <tech_description> -p <klayout_lyp>
                            -o <klayout_lyt> [-m layer_name_mapper_ruby] [-h]
```

--------------------------------

### Building All ORFS Flows with Bazel (Post bzlmod) Shell

Source: https://github.com/the-openroad-project/openroad-flow-scripts/blob/master/docs/user/BuildLocally.md

Navigates to the `flow` directory and uses `bazelisk` to build all available ORFS design targets (`...`). This command represents a future state where ORFS directly manages OpenROAD as a dependency via bzlmod, simplifying the build process as OpenROAD is built automatically as needed by the flow targets.

```shell
cd flow
bazelisk build ...
```