[Research Topic] Generative SRAF Insertion using Diffusion Models or Deep RL

[telleroutlook]

Motivation

Sub-Resolution Assist Features (SRAFs) — non-printing fragments placed near main features — are essential to keep the process window open. Today there are roughly two camps:

• Rule-based SRAF (industry standard). Fast, but brittle: dense rule tables that need re-tuning for every new node and don't transfer across pattern types.
• Continuous ILT-based SRAF (academic). Optimal in theory, but tends to produce long, fragmented "islands" that violate Mask Rule Check (MRC) and are nightmarish for mask data prep.

A generative approach — diffusion models or deep RL agents — sits in a sweet spot: it can learn the placement priors implicit in good rule tables while satisfying MRC by construction (e.g., RL with hard MRC constraints in the reward, or diffusion with an MRC-aware classifier guidance).

What we want

A new model living at src/openlithohub/models/sraf_diffusion.py (or sraf_rl.py, your call) that:

1. Takes a target main-pattern layout (binary tensor) as input.
2. Outputs a mask that includes the original main features plus SRAFs around them.
3. Honors the MRC rules for the chosen PDK (PdkRules in openlithohub.synth.pdk) — minimum width, minimum spacing, max curvature, etc.
4. Produces curvilinear SRAFs (set SUPPORTS_CURVILINEAR = True on the class) — that's the whole modern selling point.

Two flavors are both very welcome:

• Diffusion — mask-aware DDPM or guided diffusion conditioned on the main-pattern, with MRC-violation as classifier-guidance loss.
• Deep RL — agent places SRAF "stamps" sequentially; reward = process-window improvement minus MRC violations.

Interface contract

You only need to subclass LithographyModel (src/openlithohub/models/base.py) and ensure predict(design) returns a PredictionResult whose mask field includes both main features and SRAFs. EPE computation, PV-band, MRC checking, leaderboard registration, and GDS export are handled by us.

from openlithohub.models.base import LithographyModel, PredictionResult

class DiffusionSRAFModel(LithographyModel):
    NAME = "diffusion-sraf"
    SUPPORTS_CURVILINEAR = True

    def predict(self, design: torch.Tensor, **kwargs) -> PredictionResult:
        # design: target main-pattern tensor (H,W) or (B,1,H,W) in {0,1}
        # returns: PredictionResult with `mask` = main + SRAFs
        ...

See src/openlithohub/models/rule_based_opc.py for a worked example that already plugs into our benchmark/MRC pipeline, and src/openlithohub/synth/pdk.py for the PDK rule definitions you'll need to honor.

Why this is a great research target

• Hot generative topic, fresh application — diffusion has been done to death on natural images. SRAF-on-layout is unsolved and the eval is objective (process window).
• Industrial heat — TSMC, Samsung, Intel are all pouring effort into this; Nvidia's cuLitho specifically lists curvilinear SRAF as a key win.
• Conferences that love this topic: ICCAD, DAC, SPIE, NeurIPS (Diffusion / RL tracks), AAAI.

Recommended starting points

• Karras et al. (EDM, NeurIPS 2022) — the diffusion ODE formulation that's simplest to extend.
• Yang et al. (2023), "Generative SRAF Insertion Using GANs" — earlier baseline.
• Nvidia cuLitho whitepaper — for context on the industrial state of the art.
• LAMSO (Liu et al., DAC 2023) — RL-based mask synthesis that's the closest prior art.

Win-win promise

This is a highly open research problem perfect for PhD students or ML researchers looking to publish at EDA/AI conferences (ICCAD, DAC, NeurIPS, SPIE). If you decide to tackle this, the core maintainers will provide full support on the OpenLithoHub framework side. We encourage you to publish papers based on this, and we will feature your merged implementation and paper on our official website's Algorithms Showcase section.

---

Labels: research-topic, phd-friendly, help wanted, call-for-paper

---

🎯 What we expect from contributors (Your Scope)

No fab data, no real PDK, no industrial tooling required. SRAF placement is a pure algorithmic problem: input is a target main-pattern layout, output is main + SRAF mask, evaluation is "did the process window get bigger?" — all computable from synthetic layouts and the forward optical model already shipped in this repo.

Your training and evaluation set is whatever combination of OpenLithoHub/litho-tiny, the synthetic GDS fixtures under tests/fixtures/, and the ASAP7 / FreePDK45 mock cells already wired into the benchmark. The MRC rules you must satisfy are public (openlithohub.synth.pdk.PdkRules). If your model produces SRAFs that improve PV-band on these synthetic layouts while passing MRC, the PR lands — no fab partnership required.