Python module to generate text job files for an ASML PAS 5500/300 Stepper Lithography system, at the UCSB Nanofabrication Facility. Requires the relevant ASML Software options ("Job Creator") on the machine to convert the text output file into machine-usable files.

Class heirarchy is set up similarly to the ASML Job Definition GUI. The Defaults.py file, described below, may allow for usage on other ASML systems.

• You must have access to an ASML tool that has the software option JobCreator (aka. JDJC or JC) installed, in order to convert the output of these scripts into binary job files.

• You must have a Python interpreter installed in order to use this module. It is designed for use with Python 3.x, although 2.x may work (untested).

  • Common easy-to-install Scientific Python IDE's include Anaconda Python > Spyder, or Jupyter Notebooks, or the command-line Python interpreter that is built-in to many modern operating sytems.

• Download the latest ASML_JobCreator package at GitHub > ASML_JobCreator > Releases

  • Extract the ZIP into a directory of your choice, and open/run an Example file with the Python IDE

Example usage, to export a text file for import into ASML PAS stepper system via pas_recipe_import.

Edit the appropriate Example file to your needs and execute the script with your Python interpreter.

The text file produced can be copied to your ASML PAS system. On the system, execute the converter pas_recipe_import (with appropriate arguments) to generate the binary file that can be loaded into the PAS "Job Definition" GUI for further editing or the "Task Streaming Queue" for usage.

For help on a command: after importing module and creating Job object, use commands like:

help( asml )
help( MyJob )   # Print documentation on the object
dir ( MyJob )   # Lists all available attributes
help( MyJob.Cell.set_CellSize )

All units are in millimeters.

Coordinates and sizes are specified as two-valued iterables like [X,Y]

All coordinates and sizes are specified at 1x wafer-scale (not reticle 4x/5x scale).

import ASML_JobCreator as asml
MyJob = asml.Job()  # Create our Job object.

All info will be added to this Job object. Commands like help(MyJob) or dir(MyJob) will show you available options and arguments.

Set and Get methods are defined for many operations. The below comment line is optional - a default value will be provided for this and many other settings if left unspecified.

MyJob.set_comment("Demo Job", "Exported from ", "Python ASML_JobCreator")
print( MyJob.get_comment() )    # Return the current comment lines

MyJob.Cell.set_CellSize( [4.00, 4.00] )    # cell size [X,Y] in millimeters
MyJob.Cell.set_MatrixShift( [2.00, 2.00] ) # shift by half a cell

Arguments for adding an Image:

    MyJob.Image( <ImageID>, <ReticleID_Barcode>, sizeXY=coords, shiftXY=coords)

see help( MyJob.Image ) for full description of arguments.

# Resolution Test Pattern:
Res = MyJob.Image( "UCSB_Res", "UCSB-OPC1", sizeXY=[3.00, 3.00], shiftXY=[4.00, 5.00] )

# MA6 Contact Alignment Mark:
MA6 = MyJob.Image( "UCSB_MA6", "UCSB-OPC1", sizeXY=[2.00, 2.00], shiftXY=[-4.00, -5.00] )

Predefined Images can be stored as simple text files in the /Images/ subfolder inside the module folder. Alignment Marks are already implemented using this Image library, see the files in the /Image/ subfolder for examples.

A major benefit of python scripting: using nested for loops to place images across the wafer. Especially relevant to stitching images on varying pitches.

Arguments for distributing an Image on the wafer:

    MyImage.distribute( cellCR=[Col,Row], shiftXY=[X_Shift, Y_shift] )

cellCR is integer pair of Col/Row specification

shiftXY is floating-point X/Y shift from cell center

# Add Image "MA6" to a single exposure location only, offset from Cell center by 2x2mm:
MA6.distribute( cellCR=[-5, -5], shiftXY=[-2.00, -2.00] )

# Distribute Image "Res" in a 3x3 array with no shift:
for r in range(3):
    for c in range(3):
        Res.distribute( [c,r] )     # 1st arg is `cellCR`. shiftXY defaults to (0,0)
    #end for(c)
#end for(r)

print( Res )    # print Image Def/Dist. info to the console

Make a new layer, and choose which Images get exposed on it:

MetalLyr = MyJob.Layer( LayerID="Metal" )
MetalLyr.expose_Image(Res, Energy=21, Focus=-0.10)
MetalLyr.expose_Image(MA6, Energy=22)

print(MyJob)    # Print all info about this Job, including Images, Layers etc.

Example02 shows an example of exposing and aligning to Alignment marks. Mark Images are predefined in the Image Library folder.

MyJob.export( 'TestJob_NoAlign.txt' )

The resulting text file can then be imported into the ASML PAS software as a binary job file, with the pas_import_recipe command-line tool.

Verify your wafer layouts or reticle layouts using the Plot commands:

MyJob.Plot.plot_wafer():

MyJob.Plot.plot_reticles():

Default values for most options are specified in the file ASML_JobCreator/Defaults.py.
You should be able to change these defaults to match your own system, using an exported text file from your system to populate the values. For the UCSB Nanofab PAS 5500/300, defaults include settings such as:

• 100mm wafer with flat
• 6-inch reticle size
• 4x lens reduction (reticle magnification)
• default alignment methods
• default edge exclusion zones etc.

Some of these have set/get methods for manipulating them, others must be edited in the Defaults.py file.

This module is intended for users who already have experience programming their Jobs on the ASML PAS Job Definition GUI or a similar method.

The ASML Graphical Interface has many checks and tests built into the software to indicate if an invalid parameter has been entered. This python script does not replicate the vast majority of those checks. In practice, for very simple jobs this doesn't cause any problems. However, for complex jobs (eg. stitching), this means that generating a new Job for the first time requires importing the job into the ASML to determine conversion errors, modifying the script and re-importing until errors have been removed. Loading the converted job into the ASML Job Definition GUI is a good way to run the software checks.

Demis D. John, Scientist at the UCSB Nanofabrication Facility, Univ. of California Santa Barbara