Workflow to expose circle on a lens

1. Background

See:

\\vlbes-fs01\public\Departments\Engineering\Projects (Piet Kaars)\Engineering

Projects\P_14_7309 non-flat surface exposure\Curved Surface Exposures.pdf

2. Steps by step for lens

Step 1. Substrate
The surface of the lens has be known; Radius, Diameter and Height.
Deposition of chromium on lens for discharging.

Step 2. Markers
Create lift-off or etch markers on the substrate. Gold or platina lift-off marker can much more
easy to found then chromium etch in markers. (The chromium makers can only be used at
50kV, because they cannot to found with a deflected beam)

Create 8 markers. 4 markers on height level A and 4 on a height level B. A marker consists
of a 100µm square and on a distance of 200µm a square of 10um. It is even better to make

Release 1.0 1
on 100um square at one corner a small mouse bite of 4µm then small marker is easier to
found. The 100µm square is needed to find small squares, on these actual height will be
measurement.

The markers can be written with a beam of 2nA_200um at 100kV and if the top of the lens is
on the same height as the calibration marker then it can be written on a work level of high.

Step 3. Pattern
Concentric circle on a lens.

A bash program can create a TXL file which contents concentric circle. For each circle, the
radius and the height will calculate and if the height of circle get in a new height zone then
layer command will be added to TXL file. The added circles will be in that new layer.

The height of circle will be calculate with Pythagoras and where top the lens zero height is.
2
height =radiu scurvature −√(radiu s curvature )2−¿ ¿ ¿

Pattern will be divided in height zones of 20µm.

The following bash program will make circles in different height layers. Fill-in the first
parameters, linewidth, pitch, lens radius, etc. The second variables are to run the program.

bash program:
#!/bin/bash

#####################################################################
# This program create a TXL file which contents circles in different
# height zones. The height will calculate for a lens / sphere and
# divides over layers.
#
# Auteur : Bas Ketelaars, Raith B.V.
#####################################################################

#lens and line variable

Linewidth=2.0 # um
Pitch=8.0 # um
Rpattern=9000 # um (radius pattern. Maximum is the lens radius)
Rcurvature=15500 # um (radius of curvature)
Heightstep=20 # um
filename="curved_circle_RP9_RL15p5_L2p0P8p0.txl"
patternname="cc_flat"

#program variable
Height=0
Height_layer=0
Radius=0
Xpos=0
Ypos=0
Rstart=0
Rend=360
Segment=360

Halve_line_width=$(echo "scale=9; $Linewidth / 2 " | bc ) # halve line width

Halve_line_width=$(echo $Halve_line_width | awk '{printf(" %.3f\n",($1 * 1000 + 0.5 ) /
1000)}' ) # round in nm

#header
echo "TEXTLIB 9.0.0" > ${filename}
echo "UNIT MICRON" >> ${filename}
echo "RESOLVE 0.001" >> ${filename}
echo "BEGLIB" >> ${filename}

Release 1.0 2
echo "" >> ${filename}

echo "STRUCT ${patternname}" >> ${filename}

echo " LAYER ${Height_layer}" >> ${filename}
echo " WIDTH ${Linewidth}" >> ${filename}
echo " C ${Halve_line_width} ${Xpos},${Ypos} (${Rstart},${Rend} ${Segment}) ENDC " >> $
{filename}

until (( $(echo "$Radius > $Rpattern" | bc -l) )); do

Radius=$(echo "scale=9; ${Radius} + ${Pitch} " | bc )

Height=$(echo "scale=9; ${Rcurvature} - sqrt ( ( ${Rcurvature} * ${Rcurvature} ) - ( $
{Radius} * ${Radius} ) ) " | bc -l)

Intheight=$(echo "scale=9; ${Height} / ${Heightstep} " | bc )

# Intheight=$( printf "%.0f" $Intheight )
Intheight=$(echo $Intheight | awk '{printf("%.0f\n",($1 * 1 + 0.5 ) / 1)}' )

if (( $(echo "$Intheight > $Height_layer" | bc -l) )); then

Height_layer=${Intheight}
echo "" >> ${filename}
echo " LAYER ${Height_layer} " >> ${filename}
fi

echo " CP ${Radius} ${Xpos},${Ypos} (${Rstart},${Rend} ${Segment} ) ENDCP " >> $

{filename}

echo " Layer: ${Height_layer} Radius: ${Radius} till ${Rpattern} Height: ${Height} "

done

echo "ENDSTRUCT" >> ${filename}

echo "ENDLIB" >> ${filename}

If you coping the program text make sure that there are the wright double quotes!!

Output :

View in beamer

Release 1.0 3
Step 4. Fracturing
Fracturing in beamer

Flow which used in beamer contents 4 steps,

 import the TXL file

 a loop to select all the layers
 extract to correct layer (height zone)
 export to a GPF file

Import module
Select the TXL file which generated in step 3.

Loop module
Check how many layers in the TXL file.

And press generate values to create a list from 0 till highest layer
number. Add a column header name to %heightzone%

Extract module
At Layer(s) fill-in %heightzone%

Export Module:
The last part at File name must
be %heightzone%.gpf. Then ever
height zone / layer will save in a
separated gpf file.

For resolution and beam step

size the same value.

Mainfield reduce to 100 by 100

µm.

Release 1.0 4
When it run correctly, then it generate in the export folder many gpf files and each filename is
ending with a layer number. Copy the gpf files to the EBPG system in pattern folder.

Step 5. Finding the markers on the substrate

First part alignment on a microscope
Place the lens in on a piece part holder and make the top of the lens same height as the
marker height or dust below. This can be done with focusing.

Go to calibration markers under 7 deg and select one, focus and reset coordination system
and make a note to find this marker back in the EBPG. Go to the top of the lens and make it
in focus and write the coordinates done. If you have a laser height meter measure the height.

Search for the marker 100um and small markers. Write done the coordinates X,Y and if
possible the measure the Z. If not possible to measure Z then calculate later the Z value with
the following formula.

Z= R curvature2−( ( X −X top )2+ ( Y −Y top )2 )−Rcurvature + H topcentre

√
Measure at least 4 markers and one of them has to be on a different Z height. But more
markers will be better.

To write on lens with a height difference more than 200um then the machine has to operate
in working LOW. To write such kind of lens the focus point will be place 10mm lower in the
machine, by lower in the focus point the field will rotated 7deg. Recalculate of X,Y value for
worklevel low. This can be done with command high2low <Xvalue>,<Yvalue> and will results
with low coordinates.

Second part alignment in EBPG

Machine is in working level LOW and a beam is calibrated.

Move to the reverence marker, which one is use in step first part. And save or make a note of
the position

>revmark=`mpg tab`

Set the zholdercentre value to the height which 100um marker we want to find, mps
zholdercentre <Zvalue>.
Do a relative move to the marker, use the recalculate X, Y values or calculating position with
follow line.

>pg move pos `pg update ${revmark} "+" <Xvalue>,<Yvalue>`

Search in the SEM mode to marker and make it in focus. There for use zpos (mps zpos
<value>), be aware when the stage is moves in X or Y then the zvalue will go back to
zholdercentre value. So when the marker is in focus then write it down or save it with mps
zholdercentre `mpg ztab`

Release 1.0 5
When the 100um marker is found and in focus then go to the small marker 10x10um and do
a marker search and write down the position.

>pg move marker 0,0 /rel <marker_ident>

Measure the height of the marker and corrected the height with the z-stage

>pg measure height marker `mpg tab` <marker_ident>

>mpg height
>mps zholdercentre $(pg update `mpg zholdercentre` "+" `mpg height`)

If the height small value then write the Z value ( mpg zpos ) down. Now you have X,Y and Z
coordinates of the 10um marker.

Do this at least 4 markers and one of the markers must be on a different Z value.

Step 6. Calculate the centre of sphere

There two option :
 GRG Nonlinear -engine solver in Microsoft Excel
 Matrix determinant in Linux

GRG Nonlinear solver

Needed 3 point, the curvature radius and an solver add-in in excel.

To install solver add-in

The add-in has to be install only ones. Open excel and go in the menu to File, Option, Add-Ins. Select
at Manage: option “Excel Add-ins” and press Go… A pop-up window will open and check the
checkbox Solver-Add and press ok. If you do back to Add-ins then you see in list of “Active
Application Add-ins” the Solver Add_in is added. (library\solver\SOLVER.XLAM)

Create the follow layout. Cell value and formula are no imported yet.

Fill in the on the yellow cells, the 3 founded marker position X, Y, Z and radius of the lens (curvature
radius). Place the following formula’s

Cell B9 =(G$6-B5)^2+(H$6-C5)^2+(I$6-D5)^2-E$5^2
Cell B10 =(G$6-B6)^2+(H$6-C6)^2+(I$6-D6)^2-E$5^2
Cell B11 =(G$6-B7)^2+(H$6-C7)^2+(I$6-D7)^2-E$5^2

Go to in the menu to data. Click on Solver (add Analyse) And a window with solver parameters will
popup

Release 1.0 6
Fill in follow in
“Set Objective” $B$11
Check “Value Of :” 0
“By Changing Variable Cells” $G$6:$I$6

Press “Add” and create the following equations

$B$9 = 0
$B$10 = 0
$I$6 <= $D$5

Uncheck “Make Unconstrained Variables Non-Negative”

Select at “Select a Solving Method: “ GRG Nonlinear”

Press Solve and the centre Top is calculate (Xo,Yo, Ztop)

How does it work.

The formula of a sphere, top surface of a lens, can be written has ( x−xo)2 +( y− yo)2 +(z−zo )2=r 2
where r = radius of the sphere, Xo,Yo,Zo = centre point of the sphere and X,Y,Z = a point on the
surface of the sphere. For all the 3 points (3 marker positions) can this formula applied, and all the
points has the same centre point. To make the calculation easy we transfer r 2 to left side, the result of
the formula will be 0. ( x−xo)2 +( y− yo)2 +( z−zo )2−r 2=0 . This the formula is place at equation
1,2 & 3 (B9,B10 & B11).

Release 1.0 7
The solver will change centre position Xo,Yo and Zo, so that all three equations are 0 or almost 0.
In this case there 2 solutions. Because the 3 point have almost on the same height therefor the centre
can be above or below the 3 points (markers). To make sure the solver take the wright one, the one
below the 3 points. We will force it with the function $I$6<$D$5 so centre of the sphere is below the 3
markers.
Finally, add radius to the Z centre point and you get the X, Y and Z of top of the lens.

Matrix determinant
Needed 4 point where one on a different height. All 4 point cannot lie on the same plane!!
Use c-program calc_shere4pointscentre.c. It can run on the system ( see appendix ) .

It based on solving the following determinant.

It calculate the centre of the sphere and radius.

Step 7. Exposure script

Place the following script in the folder scripts or jobs. Change the following items:
Top and centre position of the lens posXC, posYC and posZC. (Not the centre of the sphere!)
Heightzone pitch.
Pattern base name, the starting and last layer
Spot and dose which are required

And start job in the command line or in the queue.

#!/bin/bash

## include error handling

. script_init_template

set x+

# Variable
posXC=86600 #105000 um centre of the lens top
posYC=146911 #105000 um
posZC=-30 #um ]
pitch_height=20 #um

patternname="cc_lr5_cr12p9_z20_0p5um_"
layer_start=0 # 0 will be
layer_end=50 # hoogste nummer

spot="5na_300um.beam_100_low" #48
dose=550

Release 1.0 8
#echo "select holder"
#pg select holder $houder

mvm
#pg set wl low

# line bss 20nm

pg arch re be $spot

echo "calibrate bundel "

pg move zpos 0mm
pg adj resist ${dose}
pg sel patt "${patternname}0.gpf " #first pattern
mcur
mvm
pg adj ebpg
pg info adj ebpg

pg set hgtinv 0
pg set calinv 0

for ((zlayer=${layer_start};zlayer<=${layer_end};zlayer++))
do
posZ=$(echo "scale=9; ${posZC} - ${zlayer} * ${pitch_height} " | bc )

pg move zpos $posZ

mps zholdercentre $posZ

pg layout clear
pg layout rectangle 26000,26000 1,1 ${posXC},${posYC}
pg select pattern "${patternname}${zlayer}.gpf"
pg information layout

echo "exposure layer=$zlayer Pos=$posXC,$posYC,$posZ "

echo "Expose started : `date`"
pg do "pg expose pattern" layout
echo "Expose end : `date`"

done #z

pg set hgtinv 1

echo "Expose finished : `date`"

Step 8. Result

The SEM image below (showing the top of the lens) shows the result of a “circular grating” exposure
on a spherical lens with a radius of 15.5 mm (diameter 18 mm) @ 100 kV, 100 μm main field size, 20
μm height zone (143 zones in total).
The exposure conditions were: 200 μm final aperture, 8 nA beam current, 10 nm beam step size and
600 μC/cm2 (PMMA).

Release 1.0 9
The txl file is clipped and merge in beamer and fractured in to gpf files.

Release 1.0 10
Appendix I Program calc_shere4pointscentre.c
Place this program in bin folder of your environment (at EBPG) . Copy Makefile in the same
folder and comply with commando make calc_sphere4pointscentre.c

Program is based on “Equation of a Sphere from 4 Points on the Surface”. Written by Paul
Bourke June 2002. ( http://paulbourke.net/geometry/circlesphere/ )

calc_sphere4pointscentre.c
#include "stdio.h"
#include "stdlib.h"
#include "math.h"
#include <time.h>

/*
Demonstration code to illustrate and check the solution
to finding the center and radius of a sphere given 4 points
on the sphere.
A sphere center and radius are chosen randomly, then four
random points on that sphere are generated, the original
center and radius are then computed from the 4 points.
*/

#define TWOPI 6.283185307179586476925287

#define PI 3.141592653589793238462643
#define PID2 1.570796326794896619231322

typedef struct {
double x,y,z;
} XYZ;
double Determinant(double **,int);

int main(int argc,char **argv)

{
int i;
time_t seed;
double r;
// double theta,phi;
XYZ c,p[4];
double **a=NULL,m11,m12,m13,m14,m15;

/* Create a known test sphere */

time(&seed);
// fprintf(stderr,"Seed: %d\n",seed);
srand48((long)seed);
r = drand48() * 5;
c.x = (drand48() - 0.5) * 10;
c.y = (drand48() - 0.5) * 10;
c.z = (drand48() - 0.5) * 10;
// fprintf(stderr,"Sphere: (%g,%g,%g), %g\n",c.x,c.y,c.z,r);
fprintf(stderr,"\nFinding the centre and radius of a sphere given 4 points on the
sphere.\n!!! All 4 points cannot lie on the same plane !!!\n\n");

/* Create 4 random points on the surface */

for (i=0;i<4;i++) {
// theta = drand48() * TWOPI;
// phi = drand48() * PI - PID2;
// p[i].x = c.x + r * cos(phi) * sin(theta);
// p[i].y = c.y + r * cos(phi) * cos(theta);
// p[i].z = c.z + r * sin(phi);
fprintf(stderr,"Enter x y z of marker %i : ",i+1);
scanf( "%lg %lg %lg", &p[i].x, &p[i].y, &p[i].z);
// fprintf(stderr,"Controle: (%g, %g, %g)\n",p[i].x,p[i].y,p[i].z);

}
/* Check input data reprint values */
for (i=0;i<4;i++) {
fprintf(stderr,"Controle Marker %i: (%g, %g, %g)\n",i+1,p[i].x,p[i].y,p[i].z);
}

Release 1.0 11
 /* Malloc the array for the minor arrays */
a = malloc(4*sizeof(double *));
for (i=0;i<4;i++)
a[i] = malloc(4*sizeof(double));

/* Find determinant M11 */

for (i=0;i<4;i++) {
a[i][0] = p[i].x;
a[i][1] = p[i].y;
a[i][2] = p[i].z;
a[i][3] = 1;
}
m11 = Determinant(a,4);

/* Find determinant M12 */

for (i=0;i<4;i++) {
a[i][0] = p[i].x*p[i].x + p[i].y*p[i].y + p[i].z*p[i].z;
a[i][1] = p[i].y;
a[i][2] = p[i].z;
a[i][3] = 1;
}
m12 = Determinant(a,4);

/* Find determinant M13 */

for (i=0;i<4;i++) {
a[i][0] = p[i].x;
a[i][1] = p[i].x*p[i].x + p[i].y*p[i].y + p[i].z*p[i].z;
a[i][2] = p[i].z;
a[i][3] = 1;
}
m13 = Determinant(a,4);

/* Find determinant M14 */

for (i=0;i<4;i++) {
a[i][0] = p[i].x;
a[i][1] = p[i].y;
a[i][2] = p[i].x*p[i].x + p[i].y*p[i].y + p[i].z*p[i].z;
a[i][3] = 1;
}
m14 = Determinant(a,4);

/* Find determinant M15 */

for (i=0;i<4;i++) {
a[i][0] = p[i].x*p[i].x + p[i].y*p[i].y + p[i].z*p[i].z;
a[i][1] = p[i].x;
a[i][2] = p[i].y;
a[i][3] = p[i].z;
}
m15 = Determinant(a,4);

fprintf(stderr,"Determinants: %g %g %g %g %g\n",m11,m12,m13,m14,m15);
if (m11 == 0) {
fprintf(stderr,"The points don't define a sphere!\n");
exit(-1);
}

c.x = 0.5 * m12 / m11;

c.y = 0.5 * m13 / m11;
c.z = 0.5 * m14 / m11;
r = sqrt(c.x*c.x + c.y*c.y + c.z*c.z - m15/m11);
fprintf(stderr,"Sphere: (%g,%g,%g), %g\n",c.x,c.y,c.z,r);

for (i=0;i<4;i++)
free(a[i]);
free(a);
exit(0);
}

/*
Recursive definition of determinate using expansion by minors.
*/
double Determinant(double **a,int n)
{
int i,j,j1,j2;
double det = 0;

Release 1.0 12
 double **m = NULL;

if (n < 1) { /* Error */

} else if (n == 1) { /* Shouldn't get used */

det = a[0][0];
} else if (n == 2) {
det = a[0][0] * a[1][1] - a[1][0] * a[0][1];
} else {
det = 0;
for (j1=0;j1<n;j1++) {
m = malloc((n-1)*sizeof(double *));
for (i=0;i<n-1;i++)
m[i] = malloc((n-1)*sizeof(double));
for (i=1;i<n;i++) {
j2 = 0;
for (j=0;j<n;j++) {
if (j == j1)
continue;
m[i-1][j2] = a[i][j];
j2++;
}
}
det += pow(-1.0,1.0+j1+1.0) * a[0][j1] * Determinant(m,n-1);
for (i=0;i<n-1;i++)
free(m[i]);
free(m);
}
}
return(det);
}

Makefile
################################################################################
# #
# Makefile for the Beams Applications #
# #
################################################################################

# This variable contains the flags passed to cc

CFLAGS = -std=gnu99 -Wall -lm

CFLAGSP = ${CFLAGS} -pedantic
CFLAGSLEX += -std=gnu99 -fPIC -pedantic

# This variable points to the directory containing the X and Motif includes.
INCDIR = /usr/include

# This variable lists the subdirectories to search for include files

INCLUDES = \
-I$(BEAMS_INCLUDE)\
-I$(INCDIR)

# This variable lists the subdirectories to search for library files

LIBS = \
-L/usr/X11R6/lib64 \
-lpthread \
-lrt \
-lm

BEAMS_LIBS = \
$(LIBS) \
-L$(BEAMS_LIB) \
-lbeams \
-lCAENVME

# This file generates the object files

.c.o:
gcc $(INCLUDES) -c $(CFLAGS) $<

Release 1.0 13
# This rule generates the executable using the object files and libraries

Release 1.0 14