UNIGIT RIGOROUS GRATING SOLVER
Osires & Optimod
D - 9693 Ilmenau
phone: +49 03677 46562
cell phone: +49 162 9067015
Reason for Change/ Extension
This is the first version of Unigit Tab
For previous versions refer to Manual Unigit version 2.02.01
changes versus previous versions of Unigit Tab
2.1. Introductory Remarks & Introduction Tab
3.1. Layer Editor for 1D RCWA (1D)
3.1.2. Rayleigh-Fourier Polygon.
3.1.3. Rayleigh-Fourier Polygon.
3.1.4. RCWA Slice, hard transition
3.1.5. RCWA Slice, soft transition
3.2. Layer Editor for 1D C-Method (1C)
3.2.1. Thin film (plane interface)
3.3. Layer Editor for 2D RCWA (2D)
3.4. Layer Editor for 2D C-Method (2C)
5.2. Retrieving input information
5.3. Retrieving stack (grating) information
5.4. Retrieving computation results
6.2. Calculation of the Diffraction Angles
Unigit is a rigorous diffraction solver for 2D (1D periodic) or 3D (2D periodic) multilayer stacks (see Fig. 1). It runs on PC with Windows NT, Windows 2000, Windows XP, Vista and Windows 7 both 32 and 64 bit machines. The schema in Fig. 1 gives an idea what types of complex patterns can be solved with Unigit.
Fig. 1: Schematic representation of a multilayer stack
Unigit V2.XX.XX comprises three basic solution algorithms:
Presently, algorithms one and three are embedded in the same S-matrix algorithm (see e.g., /4/) ensuring a high degree of stability as well as flexibility while the C-method is implemented separately. It is planned however to merge all three algorithms into one frame for upcoming versions. The algorithms can be applied layer wise, i.e., one layer can be treated with Rayleigh-Fourier and another layer with RCWA. The implementation of RCWA was done in compliance with Lifeng Li’s factorization rules (see e.g., /5/) to insure accurate results. The 2D algorithm follows closely Lifeng Li’s paper /6/. In addition, it offers the choice of the Lalanne method /7/ instead of the Li Method. The implementation of the C-method followed mainly the description in /9/ as well as some sophisticated schemas to couple the fields between non-parallel interfaces. The C-method is an ideal supplement to the RCWA. Its preferred application cases are profiles with shallow slopes made from high contrast materials. A particular case are Echelle gratings. Some examples proving the superiority of the C-method in these cases are discussed in /10/.
Unigit consists of a Graphical User Interface (GUI) and five computation kernels. The computation kernels are:
The eight computation kernels can be utilized without the Unigit-GUI by embedding it in user applications. This can be done for example with Matlab, Python, Visual Basic, C++ or C#.
In order to speed up the computation, Unigit enables the parallel threading of loops. This feature is particularly recommended to run slow 2D computations on multi-core machines. For instance, a speed up factor of about 4-6 will become possible for a dual quad-core machine. The parallel threading can be activated in the Settings tab (for more details see section 2). Moreover, the simulation of symmetric crossed gratings illuminated in a symmetric setup may be accelerated by taking advantage of these symmetries (see section 2.2).
The new (tab page based) control board is activated immediately after the UNIGIT program is started. It appears as shown in Fig. 1.
Fig. 1: New Central Control Board of Unigit
Mainly, the tab control board serves for:
It consists of seven tab pages:
These tabs and their order are designed to reflect the work flow of the code for preforming grating computations.
Besides, the basic operation modes of UNIGIT can be selected just by selecting either a regular stack file (extensions “.ust” preferred though you can use other, e.g. “.txt” have been used with older versions of UNIGIT) or a UNIGIT project file (extension “.upr”). Accordingly, there are two basic modes how Unigit can be operated:
The following sections are devoted to the regular mode. The project retrieval mode is described in more detail in section 8.
Next, the seven Tabs are discussed in more detail.
The Introduction Tab is already shown in Fig. 1. At the left side, it shows some information about the release and built number of the Unigit code. To the right, a link to the Unigit web page is provided followed by an email link to our support. Moreover, a link to the Unigit manual is given as well a link to a video presentation of the new release. Finally, the detected protection system is shown to the right.
The settings tab (see ) provides some basic settings for the program that are organised in five groups.
Fig. 2: Settings Tab
These groups shall be presented in more detail in the following.
This group (see Fig. 3) contain the permission and the settings to run parallel loops, i.e., the loop that is defined in the Excitation Tab.
After activiation of the parallel looping mode, two edit fields become active – the number (parallel) threads and the delay time between the various thread launches. An arbitrary integer number greater zero should be entered for the number of threads. The default is the number of available computation cores. However, the entered value can be different. It is recommended to find an optimum number (to achieve maximum computation speed) by means of numerical experiments. The default value for the delay time is 50 ms. It is recommended to increase this value if synchronization issues occur, i.e., single process threads fail.
Fig. 3: Parallel Loop Group (Settings Tab)
The color tab settings are closely linked to the color coding of materials and n&k files and will effect the cross section drawing in the Grating Stack Tab. The group box (see Fig. 4) enables the loading and editing of a color table. The color table itself is a simple Ascii-file that contains a list with pairs of color-ID's (names) and assigned RGB color reference values. The table can either be edited by Notepad (or another Ascii editor) or by means of the built in color table editor.
Fig. 4: Color Code Table (Settings Tab)
The color table editor enables the viewing, changing and adding of color assignments to n&k materials. In order to add an entrance, fill the material ID edit with a new name of your choice and select a color by clicking the button next to Color. Finally, append the new pair by clicking the ADD button or discard your choice by doing anything else. After adding a new pair the total score will be increased by 1. Currently, the elimination of an entrance is only possible via the Notepad editor. Alternatively, the color table can also be created and edited in a Notepad editor. An example of a color table file is shown in Fig. 5.
Fig. 5: Example of a color table file
The run group (see Fig. 6) comprises a few settings that become active during and shortly after computation runs (performed from the Run Tab).
Fig. 6: Run Group (Settings Tab)
Currently, there are 3 check boxes available in this group:
The stack file group (see ) contains some settings that become active in the Grating Stack Tab.
Fig. 7: Stack File Group (Settings Tab)
There are three checkboxes:
The Python group box in the Settings Tab is provided for loading and editing a Python script file to run Unigit.
The Excitation Tab (see Fig. 8) is devised for defining the excitation conditions for the grating computation. It offers means to run loops over the excitation parameters.
Fig. 8: Excitation Tab
Especially, the following parameters may be defined:
A loop option is linked to each of these four parameters. This means that the computation will be performed for several values of this parameter defined by a start, stop and step value.
Optionally, one geometry parameter of the stack may be also integrated in the loop selection. In order to do this, the particular parameter has to be indicated by means of a dollar sign at the end of its line in the stack file. You can do this by opening the file with the notepad button. The example in Fig. 9 shows the selection of the grating thickness as a parameter.
<![if !vml]><![endif]> <![if !vml]><![endif]>
Fig. 9: Activation of a wild card loop (via $ sign)
The mark is recognized automatically and an additional radio button together with input field(s) pops up after saving the change and leaving the notepad editor. This is shown in ???. If the “/d” box is checked, than the loop parameters are related to the pitch, i.e., entering 0.2 at pitch 0.5 microns means 0.1 micron.
Fig. 10: Activated and selected wild card loop
The looping group permits already quite some versatility in terms of looping. However, it is limited to the variation of just one parameter and to equidistant steps. This can be overcome by the Flexi loop. In order to activate it, the Flexi loop box has to be checked (see Fig. 11) and a loop control file (extension .ulf) has to be loaded.
Fig. 11: Activated Flexi Loop (Excitation Tab)
An example of an .ulf file is shown in Fig. 12. The parameters have to be listed in exactly the order as shown in the figure. Furthermore, the total number of parameter sets has to be entered in the second line (here 6). Beside of these constraints, the parameter values in each line (corresponding to a parameter set) are quite arbitrary within the range of physical values. Of course, single loops can also be specified but as opposed to the single loop selection, a variable step width can be invoked such as shown in the example of Fig. 12. Finally, the output parameter of the set which shall be appear in the output file (parameter to be printed) can also be selected via the radio buttons (theta_i in the example of Fig. 11).
Fig. 12: Example of an Unigit Loop File (.ulf)
The mount selection offers two choices – the classical and conical mount. In the classical mount, the incident beam remains in the grating plane (defined by the grating vector which is perpendicular to the grating grooves and the normal vector for 1D gratings). Whereas in the conical mount it can be outside. Different solvers are required in 1D for the polarization modes do couple for conical mount and don’t couple for classical mount. In this way, the selection determines which solver has to be run (unigit_1D or unigit_1C for classical and unigit_1DC or unigit_1CC for conical mount). It has to be noted, that comparisons can be made for both solvers by selecting on the one hand classical mount and on the other hand conical mount and setting Phi = 0°.
In general, the mount doesn’t matter for 2D gratings. However, if unigit_2DSX shall be run for symmetry acceleration, the corresponding check box “Sym Oblique” in the Run Tab will be only available by choosing conical mount and setting Phi = 90° while the unigit_2DS0 check box “Sym Normal” will only be available when choosing classical mount and setting AOI = 0°.
The Grating Stack Tab provides more or less the functionality of the former stack editor (until version 2.02.01). In addition, a cross section drawing of the stack can be shown optionally on the right hand side of the Tab as shown in Fig. 13. According to the dimensionality (1D or 2D) and to the solution method (RCWA or C-method) there are 4 basic grating types available in Unigit. The dimensionality and solution method can be chosen when creating a new grating by clicking the wanted radio buttons. In case, a grating is selected from a database, these options are detected from the grating file and set automatically.
As long as no valid grating is selected, it is indicated with red color in the stack file group. Similarly, the color changes to red as soon as the grating is changed by editing one of its parameters. In order to run the grating structure that is exhibited in the grating editor on the left-hand side of the Tab, one has to make sure to save it first. After successful saving, the color of the stack file path turns into black.
In the following subsections, first the basic features of the stack editor are explained and then, the four basic grating types along with their implemented layer types are presented.
Fig. 13: Grating Stack Tab with cross section drawing of the multilayer stack
The stack editor is integrated into the Grating Stack Tab and facilitates the assembling of arbitrary multilayer grating structures for each of the four basic grating types. The types of layers to choose from are context sensitive, i.e., they depend on the selected solver type and dimensionality. For the editing, a number of buttons are arranged below the spreadsheet list.
There are several feasibilities to assemble the stack.
This functionality can also be accessed via hot keys as follows:
For 1D (line gratings) there are 5 basic types of layers:
In addition to these basic layer types, so-called composite layers can be input:
A symbolic layer stack comprising all these layer types is shown in Fig. 14.
As opposed to the sinusoidal or polygonal Rayleigh-Fourier (/3/) layer, the corresponding composite layers are automatically decomposed (that means sliced) into discrete RCWA slices of type 4 immediately before being processed. A sequence of layers (also called sub-stack) has to be stored as a file in the same way as the total stack description is stored. The only difference between a complete stack and a sub-stack consists in the fact that the complete stack comprises beside the stack data the grating period as well as the superstrate and substrate description. Moreover, a hierarchy of sequences is not permitted, i.e., a sub-stack must not contain another sub-stack. As for layer editing see section layer editor.
Fig. 14: Example for a RCWA 1D layer stack
This editor enables the assembling of stack files for the C-method. An unlimited number of non-parallel interfaces is permitted. The stack editor considers the interface as a “layer” just like in the same way as it does for Rayleigh-Fourier interfaces. This arises from the layer-wise processing of RCWA-slices. Basically, the stack editor enables several choices:
The interface types are uniquely identified by its names. Beside the corrugation of the layers, the distances and if existent the material ID's are shown. Note, that there is no distance entrance for the uppermost interface (because it would have no meaning). An example of a multi-layer stack containing all different layer types is shown in Fig. 15.
Fig. 15: Example for a C-method 1D grating stack
There are basically 6 types of layers:
Here, the types: thin film, patch, ellipse and fill2d are genuine 2D layers whereas 3D cone and sequence are composite 3D-shapes formed by the basic 2D types (i.e., all 4 types are possible for sequence and ellipse type is used for 3D cone).
An example of a multi-layer stack containing all different layer types for a RCWA 2d stack is shown in Fig. 16.
Fig. 16: Example for a RCWA-method 2D grating stack
There are basically 4 types of interfaces for c-method 2D:
In the current implementation, only one out of the types pyramide, micro-lens and fill2c can be chosen as bottom interface. In addition, only one interface of type “parallel to previous” can be put on top of it resulting in a maximum number of two interfaces. Examples are provided in Fig. 17, Fig. 18 and Fig. 19.
Fig. 17: Example of a 2C stack with a pyramid interface
Fig. 18: Example of a 2C stack with a micro lens interface
Fig. 19: Example of a 2C stack with an arbitrary interface (fill2C) load from a file
The output format (or control) tab replaces the output editor window of former versions (up to 2.02.01). The appearance of this tab is shown below in Fig. 20.
Fig. 20: Output Format Tab Page
It contains 5 groups and a number of file selection inputs in the lower part.
These groups are discussed in the following.
This group is located in the upper left of the tab page. Here, the following choices can be made:
Basically, the following coding is used:
Assume the basic name as specified in the text box is “test”. Then, the file name is testOXOY.MPP where
The group is the second from left in the upper half of the page. In this group, the numerical format of the outputted results can be defined.
There are the following choices:
<![if !vml]><![endif]>In this group (third in the upper half) it can be selected which orders to output in the result. A range of orders has to be specified from (minimum) order to (maximum) order for both reflection and transmission (and x and y for 2D gratings). In the example shown in Fig. 21, the –2. through +2. order and the -1. through the +2. order are output in reflection whereas order -3 through 3 and order -3 through +1 are output for transmission, in x and y, respectively. Moreover, the propagative orders (in reflection) can be determined and automatically filled-in by clicking the PROPAGATIVE ORDERS buttons.
Fig. 21: Output orders group
In this group (outer right group in the upper half), the kind of output values can be chosen as follows:
In addition, the checkbox “Diffraction Angles” allows to include the diffraction angles (AOI and phi) in the output. An example is shown in Fig. 22.
Fig. 22: Example of result output with diffraction angles
The file selections (arranged in the lower half of the page) on the one hand define the path where to save the result file(s) (top most) – in the example of Fig. 20, it is C:\Osires\Unigit\Results\test_2d.txt.
Below, a checkbox enables the output of an Unigit project file (for more information see section 5).
This is followed by for rows with checkboxes to define the output of complete diffraction matrices for reflection and/or transmission along with the paths where to save the data.
A file requester is opened when clicking the “…” buttons.
The path and the name of the output control file is the entrance in the third line of the unigit.ctr file. This file contains exactly the information of all groups of the output control tab.
It can be saved and loaded again. In this way, settings for the output control can be assembled conveniently in the tab page and quickly recovered if necessary.
The Run Tab provides the platform for running any kind of grating computations. A cutout is shown in Fig. 23. Basically, the Tab contains two main groups – the regular mode and the batch mode. Besides, there are checkboxes for the choice of polarization and a button to output the diffraction angles in a text-file. The groups are discussed in more detail in the following subsections.
Fig. 23: Run Tab
The regular mode group provides all means for a regular computation run (meaning a simple loop inclusive a flexi loop – see Excitation Tab, section 2.3.2). In order to start the computation, the user has just to push the “START” button on the right hand side. Moreover, some sub-groups on the left hand side permit to select some special options for 2D RCWA stacks to run:
The batch mode group represents an automation of Unigit computation runs. In this way, the user may run consecutively an arbitrary number of runs without any action in between. All he has to do upfront is do assemble a special file that controls the further computation process. In order to commence the batch process, he has to open a batch file (characterized by the extension *.ubf) by first, pushing the “LOAD” button and select an ubf-file from a database and second, click the “EDIT” button to edit the selected file. An example that comes with the installation is ubatch.ubf (shown in Fig. 24).
Fig. 24: Example of an Unigit-batch file (ubatch.ubf)
Each line describes one independent computation sample and contains six entrances:
if the loop parameter is < 0, the symmetry computation kernel is run for 2D instead of the regular 2D exe;
The design of the unigit.ctr file is fixed and comprises just three files in fixed order:
The structure of the unigit input.ctr file is explained in section 6.1.2 and those of the output.ctr file in section 6.1.3.
Note, the exe kernel is selected according to the type of the stack file. For a 1D RCWA stack, unigit_1D.exe is run in case of phi_i = 0 and unigit_co.exe otherwise.
The batch processing is started with the "Run Batch" button. During processing, the progress is shown both on the "Batch" button (shows the current process out of the number of total processes) as well as by means of the familiar progress bar at the location of the "Start" button (showing the progress of the current process). An example is shown in Fig. 13. Here 13% of the first process out of four total processes is already executed.
Fig. 25: Progress display during the batch processing mode
The current process of a batch can be cancelled by means of the "Cancel" button if it is a sequential process. Then, the processing jumps to the next process in the *.ubf file.
The remaining elements are the “START” button and some information text fields above (shown in Fig. 26). The “Show Result” is activated when the box “Immediately” in the Settings Tab is checked (not activated = “show off” in the example). The “Exe to run” is a placeholder for the selected solver exe and will be updated after the “START” button is hit (here with UNIGIT_2D). Moreover, the “Check Input” button opens the input.ctr file in Notepad for quick control of the right setting. Finally, a text field below the “START” button shows the elapsed computation time for the last run.
Fig. 26: Elements around the start button
Furthermore, the location of the diffraction angles for a given example (consisting of the grating stack and the excitation conditions) can be output to a text file by clicking the “Print Diffraction Angles” button.
This is the last Tab in the Unigit processing order. An example is shown below (Fig. 27).
Fig. 27: Show Results Tab
A result file selector is located in the upper half of the tab. Files can be selected by means of the “Add” and “Remove” buttons. The list can be completely cleared by means of the “Remove All” button. After the list is completed, it can be visualized in a diagram just by checking the “Show Diagram” box below (see example in Fig. 28).
Fig. 28: Diagram tool in the Show Results Tab
Unigit version 2.01.02 upwards features a new diagram tool provided by UrcomTech Berlin/ Germany. It is based on an activeX library and has to be registered before usage.
The implemented diagram tool offers the following options to modify the plot:
<![if !supportLists]>· <![endif]>Switching the legend on/ off by checking/ unchecking the associated box,
<![if !supportLists]>· <![endif]>Autoscale the diagram to min/ max range by checking/ unchecking the associated box,
<![if !supportLists]>· <![endif]>Scale the diagram by entering min/ max values for x and y (axes group),
<![if !supportLists]>· <![endif]>Change the font type and size (font group),
<![if !supportLists]>· <![endif]>Select the active curve number # by means of the up/down arrows (curves group),
<![if !supportLists]>· <![endif]>Change the label name of the active curve by entering the new name into the label edit field and push the Update button,
<![if !supportLists]>· <![endif]>Change the color of the active curve by means of the color selector,
<![if !supportLists]>· <![endif]>Change the marker type of the active curve by means of the marker type selector,
<![if !supportLists]>· <![endif]>Change the pen size of the active curve by means of the pen size selector,
<![if !supportLists]>· <![endif]>Delete the active curve by means of the Delete button,
<![if !supportLists]>· <![endif]>Connect/ Disconnect curve points by checking/ unchecking the Connect Points box,
<![if !supportLists]>· <![endif]>Note: all changes in the curves group have to be activated by means of the Update button,
In the lower half, a check box, two buttons (Notepad and Excel) and a text field with a selector button (“…”) to its right can be found. The text field contains the result file (as selected in the Output Control Tab). It can be opened as text file with the “Notepad” button. On the other hand, it is also possible to open it directly with Excel (use the “Excel” button). In case, the German decimal comma is activated in the system settings, the box “German CSV” should be checked before.
The layer editor is closely bound to the stack editor (see section 2.4.1). The available layer types depend on the choice of the dimension and the method. The layer editor serves for assembling a grating stack. It is activated whenever either the button “Add” or the button “Edit” is hit in the Grating Stack Tab. For the latter, a layer has to be selected before. The layer editor is context sensitive depending on what kind of grating is selected.
Unigit offers four different basic types of stacks where each has it’s own genuine layer types. These basic types distinguish between dimension (1D and 2D) and method (RCWA and C-method) – see also Grating Stack Tab in section 2.4. The specific layer types of these different gratings are discussed in the following sub-sections.They are presented in the next sub-sections.
Currently, there are 9 layer types available for 1D RCWA gratings (see section 2.4.2). They fall in
five basic and four composite types. The layer type is selected via the arrow-down button in the drop list “Layer Type”. All layer types are presented briefly in what follows.
A thin film is the most elementary layer type. It consists of a flat homogeneous layer on top of a plane underlay. Thus, it requires only two parameters for complete description – thickness and material (see Fig. 29). In addition, an arbitrary name can be assigned to each layer.
Fig. 29: Thin film layer
The editor look for the selection of a Rayleigh-Fourier (RF) polygon is shown in Fig. 30. The Rayleigh-Fourier method is an additional solver method beside the RCWA. It is very fast but fails if the so-called Rayleigh hypothesis (for a sine profile with y = h*cos(kx) & k = 2pi/l holds that the method only converges if k*h < 0.448) is violated (in many cases it works also beyond this limit).
Fig. 30: Rayleigh-Fourier polygon
Actually, the Rayleigh-Fourier polygon represents an interface rather than a “layer”. The interface itself follows the polygon points in the list box. Moreover, the materials above and below the interface (medium 1 and 2) have to be specified. The absolute PV-value of the interface is given by the entrance in the “Thickness” field. The z-points in the polygon list are renormalized correspondingly. Polygon points can be added (“Insert”), removed or replaced by means of the buttons below the list. Furthermore a polygonal interface can also be load from a file (“Load” button). As a default, all x-values (lateral coordinate) are normalized to 1. The absolute values are shown when the box “abs” is checked. In addition, it is possible to check the box “trap” when the total number of polygon points equals 6 or to check the box “blaze” when the number of polygon points is 3. In either case, the appearance of the editor changes from polygon point input to parametric input. The new parameters are CD and side wall angles (SWA) for the trapezoid and only SWA for the blaze grating (see Fig. 31).
Fig. 31: Parametric input modus for RF-polygon layer (left trapezoid, right blaze)
In both cases, the profile can be shifted laterally by means of entering a phase shift value for x0 (an example for the trap case is shown in Fig. 32).
Fig. 32: Lateral shift of the RF profile by modifying x0
The RF Sine is similar to the polygon (same method, similar parameters) however the polygonal profile is replaced by a sine profile (see Fig. 33). Thus, it requires only a height (here thickness) to specify this layer type. In addition, a lateral shift is possible by means of the x0 input. In the example below a value of x0 = 0.1 causes a shift of 1/10 pitch to the right.
Fig. 33: RF Sine Layer
Beside the thin film, the RCWA slice is the most elementary layer type of the 1D RCWA grating. One of the strengths of RCWA is that quite arbitrary and complicated grating profiles can be put together with these slices (so-called stair case approximation).
Fig. 34: RCWA slice (discrete)
The appearance of the layer editor for the RCWA slice is depicted in Fig. 34. Each slice is a slab of constant thickness consisting of an arbitrary number of partitions (as it is called in Unigit) meaning areas of homogeneous material that are separated by vertical borders in the default case, i.e. skew value = 0. The partitions (and thus the grating lines) can be skewed by entering a value different from zero (skew angle in degrees). The location of the border is indicated by the first column (x) in the list. The third column contains the material descriptor. Partitions can be inserted, replaced or deleted by means of the buttons on the bottom. In order to insert a new partition, an x-value has to be entered and the refractive index has to be edited.
This layer type (see Fig. 35) resembles closely the standard RCWA-slice as described above (section 188.8.131.52). The main difference in the appearance is that there are no discrete partitions but more or less smoothly changing materials. This are defined in a file which has the standard extension *f1d.
Fig. 35: Layer editor for RCWA slice 1D, soft transition
An example for a f1d-file is coming with the installation (unigit_grating_layer.f1d). Its composition is rather straightforward:
Not only is the input different compared to the hard transition RCWA slice, but there is also a different processing. While for the standard slice with discrete partitions consequently a discrete (analytic) Fourier transformation is applied, a FFT is used for the soft transition. This results in a smoothing of the material transitions across the slice. Both types enable the modelling of volume holograms.
This layer type is the first composite type, i.e. it is formed with standard RCWA-slices. An example is shown below (Fig. 36). Similar to the Rayleigh-Fourier layer types, two materials have to be specified (#1 above and #2 below the interface borderline). The polygonal interface is described by a number of consecutive x,z point pairs. Switching to a parametric trapezoid is likewise possible by checking the “Trap” box. Moreover, the profile can be shifted laterally by means of the x0 input (0.1 in the example below). As opposed to the RF-layer types where the profile is processed as one (and thus constrained by the Rayleigh hypothesis), the profile is sliced. The slicing itself is controlled by the parameters “DeltaX” and “DeltaZ”. Basically, the number of slices increases with decreasing values of those parameters. The slicing information is stored in a sequence file and can also be reused later ().
Fig. 36: Sliced Polygon Layer
This layer type is quite similar to the previous one. The main difference is that the profile is specified by a Fourier formula instead of polygonal point pairs. The most simple example is a sinusoidal interface as shown below (Fig. 37).
Fig. 37: Sliced Fourier Layer
The Fourier formula is a definition of the profile in terms of parametric Fourier series. Here, both the ordinate and the abscissa are given as a Fourier series of a parameter t as follows:
Instead of the direct input of the interface by means of point series, the coefficients ZAk and XAk as well as the phases ZPk and XPk have to be entered. If one would set all coefficients XAk to zero it would lead to the known Cartesian Fourier presentation. An example for using the first 3 even Fourier coefficients is shown in Fig. 38.
Fig. 38: Fourier composition of a profile with first 3 even coefficients
Generally, the parametric Fourier series allows to describe rather complicated profiles (including overhangs). An example for an overhanging is given by Fig. 39.
Fig. 39: Overhanging profile by parametric Fourier series
For numerical reasons, the interface description as obtained from the parametric Fourier formula is translated into polygonal points before processing. The number of points (input bottom center) effect both accuracy and speed.
The previous two layer types (sliced polygon and sliced Fourier) offer a lot of versatility specifying complicated profiles. However, they are useless when multiple layers are interpenetrating each other. The sliced multi-layer addresses this case. The example below (Fig. 40) shows an interpenetration of material red, blue and white at heights between 100 and 240 nm.
Fig. 40: Editor for sliced Multi-Layer type
The input handling for this layer type is as follows:
An example is shown below:
0 // '' *Direct Input*
(0.500000,5.000000) // Refraction Index
6 // # of polygon points
0 // '' *Direct Input*
(1.500000,0.00000) // Refraction Index
6 // # of polygon points
0 // 'Air' Direct Input **
(1.0,0.0) // Refraction Index
The first line is reserved for the identifier ('UMF File'). It is followed by the interface data in a bottom up manner, i.e., interface 1 is the bottom most one. Each interface is described by the material below it, followed by the number of (x,y) points and the points itself (x first, y second). It is mandatory that the first and last y value are identical (to connect the adjacent period of the grating). Finally, the material above the top most interface is listed.
In general, slicing information is saved into a sequence file. Thus, it serves two purposes – first to provide the slicing for the RCWA processing of the composite layers (see sections 184.108.40.206, 220.127.116.11 and 18.104.22.168) and second, to keep the information for reusing in other stacks. The input mask is rather straightforward (Fig. 41). All one has to do is to load a sequence file (extension *.SEQ).
Fig. 41: Sequence Layer
After being loaded, the sequence file can be either edited with a built-in tool or just opened in a Notepad editor (where it can also be modified of course). The built-in editor resembles closely the stack editor and is opened by clicking the “Edit” button. Fig. 42 shows an example. The layers can be processed in the same way as in the stack editor (see section 2.4.1) by means of the “Add Layer”, “Edit”, “Move up”, “Move down”, “Copy”, “Cut”, “Paste” and “Delete” buttons below.
Fig. 42: Sequence Editor
All thicknesses of the sequence layers are renormalized to add up to the specified (total) thickness of the sequence layer.
RCWA and C-method are different modal solver methods for grating diffraction. While RCWA is based on so-called slices by means of which almost every kind of profile can be put together, the C-method relies on a coordinate transformation of the profile. Therefore, the elementary “layer” types for C-method are interfaces separated by a certain distance rather than layers having a certain thickness as in RCWA.
Currently, the 1D C-method in Unigit comprises 8 different layer types (see also 2.4.3). These are presented in the following.
Actually, the term thin film is a bit misleading here for in c-method interfaces are used rather than layers. Thus, it would be better to call this type plane interface. An example is shown in Fig. 43. Nevertheless, a plan thin film can by constructed by just putting two plane interfaces on top of each other.
Fig. 43: Plane interface of 1D C-method
The input mask is almost identical to the thin film of RCWA except there is no thickness but a distance instead. It specifies the distance to the interface immediately above (in case there is any).
The layer editor for the CCM polygonal interface is shown in Fig. 44. There are entrances for the corrugation of the interface (corresponding to the height of the profile) and the distance to the next interface above. Due to the specifics of the C-method, there are no overhanging or undercut features allowed (see /8/, /9/). The material between the shown profile and the profile above is verified in the refractive index entrance. Moreover, it can be chosen between absolute or relative input of the polygonal point pairs.
Fig. 44: Layer editor for a 1D CCM polygon layer (to be run with C-method)
The layer editor for the CCM sinus layer is shown in Fig. 45. It is very similar to the RF sinusoidal layer, i.e., there entrances for the amplitude (thickness of the layer) and the lateral phase X0. For the uppermost interface, the index selection and the distance entrance are not visible. In this case, the n&k index will be set automatically to the superstrate index that is specified in the stack editor (see section 4).
Fig. 45: Layer editor for CCM-sinus
The parallel to previous type must not be confused with the plane interface of section 22.214.171.124. Its input editor look is shown in Fig. 46.
It helps to simplify the computation in case of an interface being parallel to the interface below (which can be of any shape). Here, parallel means that the thickness of the layer beneath (specified by the distance in the interface below) this type of interface is constant everywhere.
Fig. 46: Layer editor for Parallel to Previous Interface in C-method
The sequence type is not yet available for the C-method. It is going to have a similar meaning as for RCWA.
The CCM-Trapezoid (see Fig. 47) is a special interface derived from the more general CCM Polygon. It offers three parameters to define the trapezoid profile – the CD and the two side wall angles left and right. The corresponding polygon points are passively plotted in the polygon point list (and updated with changing any of the parameters).
Fig. 47: CCM Trapezoid Interface
Likewise, the CCM measurement interface (Fig. 48) is another special case of the CCM polygon. However, the polygon points are read from a file rather than being entered by means of the point list editor. To this end, a file has to be loaded by clicking the “Load File” button on the bottom. Accepted file extensions are *.AFM (for this type was devised to input measurement data from AFM) and *.TXT (standard ASCII text). Examples for the file format are provided with the installation package.
Fig. 48: CCM Measurement Interface
Finally, the CCM triangle (Fig. 49) is another special case of the CCM polygon with 3 points. Again, the profile is specified by parameters. This can be either the two side wall angles (box “Type” is unchecked) or the base (x-coordinate of the triangles top peak) and the corrugation (see Fig. 50).
Fig. 49: CCM Triangle Interface – type 1
Fig. 50: CCM Triangle Interface – type 2
Similarly to 1D RCWA, the elementary types for this kind of stack are layers. Currently, the 2D RCWA in Unigit offers 6 different layer types (see also 2.4.4). These are presented in more detail below.
The thin film layer for 2D RCWA is identical to the 1D case.
This layer type will be of advantage if your 2D area can be approximated by means of rectangular patches. With the help of the editor you can specify the position of the patch as well as its material within the elementary cell. In addition, you need to enter the thickness of the layer. An example is shown in Fig. 51.
Fig. 51: 2D RCWA Patch layer
The rectangles are specified by 2 diagonal corner points (x1,y1 and x2,y2) and its material entry (by means of the refraction index editor). The embedding material is medium 1. Note that the editor does not allow to overlap patches (when the “Insert” button were hit in Fig. 50, the new outlined patch would not be accepted). In general, an arbitrary number of patched can be inserted however there is some kind of limitation from a practical point of view.
Note that unlike the super-ellipse layer, there is no “orthogonal” option, i.e., the patch is always defined in the given coordinate system. This means in other words that patches which have been defined in a non-orthogonal system (pitch angle different from 0) are parallelograms in the real world.
Contrary to the patch layer type where a number of different areas can be specified, the super ellipse layer type may include only one or two feature. However, this feature is a less restricted one, namely a super ellipse. The mathematical expression for a super ellipse is given below:
In case a second ellipse is admitted, the two ellipse are allowed to overlap or to be nested as in the example. In this case, the second ellipse overwrites the first one. The appearance of the layer editor for an ellipse is shown in Fig. 52.
Fig. 52: Ellipse Layer
The embedding medium is medium 1 and the ellipse is medium 2. The dx and dy are the diameter in x and y direction whereas sx and sy are the relative lateral shifts. Angle is the rotation angle of the ellipse. Unlike a regular ellipse with power p = 2, the power p of a super ellipse can be an arbitrary positive rational number. In this way, a range of features between an ellipse and a rectangle (p = infinity) can be covered. Moreover, a diamond can be described with p = 1 and concave shapes with p < 1. Two cases are shown below.
In addition, the ellipse can be rotated by specifying the wanted rotation angle and it can be shifted laterally by entering the correspond relative values into the edit fields sx and sy. By checking or unchecking ”Ortho” you can define whether or not the ellipse is ”orthogonal” in real world in spite of a non-orthogonal cell (defined by zeta – see stack editor). For further explanation see also the drawing below.
Check the box Ortho if you want to have an ellipse in real world, otherwise the ellipse is defined for the non-orthogonal coordinate system, i.e., it will be distorted in real world. Schematically, this is shown in the drawing below (Fig. 53). Notice, the drawing in the editor (see Fig. 52) does not show this, however, your calculation result is supposed to be different for the cases of a checked and an unchecked Ortho box.
Fig. 53: Orthogonal and Non-Orthogonal shape of the ellipse in a non-orthogonal coordinate system.
Unigit offers a feature for arbitrary pixel filling of a 2D layer. It is comparable to the gradient RCWA (or soft slice) in 1D. If you want to include an arbitrary fill layer then pick the Fill2D option in the drop down box of the 2D layer editor. Then, the layer editor opens with the window shown in Fig. 54.
Fig. 54: Fill 2D Layer Editor
Here, you need to specify the layer thickness and you can enter a name for the layer similar to other layer types. Moreover, you need to specify a material for the embedding medium and a file (with the extension *.f2d) which contains the bitmap description of the layer.
The file content is explained as follows:
2 /number of materials beside the embedding material
0 /specification ID for material 1 (0 = direct input)
1.5 0.0 /n&k for material 1
1 /specification ID for material 2 (1 = n&k file)
'C:\Program Files\OPTIMOD\Unigit\NKData\SILICON.NK' /pathname of the n&k file for material 2
6 97 /Fourier discretization power (e.g., discretization is 2^6) & number of lines to follow
528 0 /pixel number & material ID, e.g., 528 pixels with material 0 (embedding material)
32 1 /pixel number & material ID, e.g., 32 pixels with material 1
32 2 /pixel number & material ID, e.g., 32 pixels with material 2
32 1 /pixel number & material ID, e.g., 32 pixels with material 1
528 0 /pixel number & material ID, e.g., 528 pixels with material 0 (embedding material)
Note, the total number of pixel description lines in this example must be 97 and the total number of added pixel numbers (i.e., 528 + 32 + 32 + … + 32 + 528) must be equal to (26)2 = 4096.
A graphical example for a non-orthogonal cell is shown below. First, the elementary cell has to be defined as shown (red color in Fig. 55).
Fig. 55: Determination of the elementary cell
As a next step, one has to do the discretization in unit cell coordinates. The linear pixel number has to be a power of 2 (64, 128, 256 etc.). The pixel number in both axes has to be the same (no matter what the pitch is).
Fig. 56: Filling of an arbitrary layer
The counting direction is indicated by the green arrows in Fig. 56, i.e., scanning row by row with blanking like behaviour (jump from the end of one row to the begin of the next row) as shown. As long as pixels have the same material (defined by largest area percentage) just add, when material is changing ® save the value and restart counting (across scan blanking).
This would result in the following *.f2d information for the graphical example assuming material 0 is white and material 1 is blue:
48 0 (3 lines with 16 pixel each)
3 1 (3 pixels blue)
6 0 (6 pixels white)
10 1 (7 pixels in row #4 right hand and 3 pixels in row #5 left hand, counting across the blanking)
5 0 (5 pixels white)
The installation of version 2.02.02 comes with 3 stack files that describe all the same geometry (a rectangular area with n = 1.5 embedded in vacuum with n = 1) but with different means:
<![if !supportLists]>· <![endif]>stack2d_elli.ust using the ellipse descriptor (ellipse filling),
<![if !supportLists]>· <![endif]>stack2d_arbi.ust using the new bitmap descriptor (arbitrary filling),
<![if !supportLists]>· <![endif]>stack2d_rect.ust using the patch descriptor (patch or rectangle filling).
Running these files should give very similar results (for details see Unigit tutorial).
This layer type permits to insert real 3D structures by means of a very compact description. It is quite similar to the 1D composite layer types in the sense that an automatic slicing works behind the scenes to transform the input description in a number of 2D slices of the 2D ellipse layer type. It is activated by selecting the CONE-3D option in the 2D layer editor. In doing so, the layer editor window as depicted in Fig. 57 shows up.
Fig. 57: 3D Cone Layer
Here, the user can define the top and the bottom cross section shape of his grating pattern just like the same way as he is used to with the ellipse filling feature. But as opposed to it, now a real 3D body is defined. The vertical shape of this body is defined by the vertical power. Here, a 1 results in a straight line while a value >1 gives a convex and a value <1 results in a concave shape, respectively. Furthermore, the user can define the number of slices. Actually, an equidistant slicing routine takes care to automatically translate the compact 3D description in something digestible for the RCWA solver. Finally, the user can sweep up and down through the 3D body by means of the “Show Slice” option. Here, the cross section shape of the activated slice number is plotted. Fig. 58 shows such a sequence of cross sections for the body defined above.
Fig. 58: Sequence of cross sections when vertically sweeping through a 2D composite layer
The layer type sequence just like the type thin film layer is common for 1D and 2D. The difference is that a 1D sequence can only contain 1D layer types whereas a 2D sequence has to contain 2D layer types only. However, the appearance of the layer editor will be the same. Basically, a sequence can only be used if defined before. If a sequence layer is to be built into a stack, the location of the stored file has to be specified in the corresponding edit field. In addition, the total thickness of the sequence has to be entered. The structure of the sequence (or sub-stack) is renormalized to this thickness. Likewise, the lateral dimensions are renormalized to the new pitch (grating period). The button EDIT permits to edit the sequence in the stack editor whereas the button Notepad opens a notepad with the sequence in ASCII-format.
Similarly to 1D RCWA, the elementary types for this kind of stack are layers. Currently, the 2D RCWA in Unigit offers 6 different layer types (see also 2.4.4).
Presently, there are four interface types implemented with the restriction that only a stack with parallel interfaces can be processed. This means that except of the bottom interface (that has to be of type pyramide, micro-lens or fill 2C) all interfaces above have to be of type parallel layer (see section 3.4.1).
All interface types are presented in more detail below.
The parallel interface for 2D C-method (Fig. 59) is identical to the 1D case. Parameters to input are the material (above the interface) and the distance to the interface above (if there is any).
Fig. 59: Parallel Interface for C-method 2D
The pyramide interface (Fig. 60) is characterized by its Top CD in x & y (TCDx, TCDy), its bottom CD’s (BCDx, BCDy), its height and the rotation angle (describing the tilt of the pyramide relative to the elementary cell of the grating. Additional parameters to input are the resolution (required for the FFT during processing), the material above and the distance to the interface above. Moreover, the checkbox “Inverse” offers to turn around (i.e. to put it upside down) the pyramide. A false color plot in the lower right half shows the shape synchronously.
Fig. 60: Pyramide interface
This interface allows the modelling of a micro-lens array. The required parameters (see Fig. 61) are the lens radii in x and y direction (Rad x & Rad y), the conical constants (Con x & Con y) and the height of the micro-lens. Again, a resolution for the FFT and a rotation angle (defining the relative tilt of the lens w.r.t. the elementary cell) can be entered. Also, the micro-lens can be inverted, i.e. showing upside down. The footprint of the lens is calculated and displayed in the Edge x & y fields. Like for all other 2C layers, the material above the interface and the distance to the interface above have to be specified.
Fig. 61: Micro-Lens interface
This interface type is devised to enable the input of an arbitrary 3D surface into the 2D C-method algorithm. This is achieved by loading a surface fill file (extension *.F2C). After the file is loaded, the surface is shown in a false color plot (red = high and blue = low heights) on the lower right. Moreover, the height, the distance to the interface above and the refraction index have to be entered into the editor mask (Fig. 62).
Fig. 62: Fill 2C Interface
The structure of the *.F2C surface file is as follows:
The height values are relative. They are normalized with the height value to be input into the “Height” edit field.
The n&k editor serves the definition of the refraction indices of all materials needed to build the layer stack, i.e., the substrate, the superstrate and all kinds of layers between. It is available wherever required within the stack editor. To call the editor one has simply to click the related EDIT-button.
Related to the three basic possibilities of describing the materials, the appearance of the editor changes correspondingly. After being called, it comes always up in the direct refraction index input mode. Other selections can be straightforwardly made by choosing the wanted option in the drop down box. This is shown in Fig. 63 along with all the possible options.
Fig. 63: Selection of the refraction index input mode
The available selections fall into three basic options:
The direct refraction index input mode is shown in Fig. 64.
Fig. 64: Refraction index editor
Here, the real and the imaginary part of the refraction can be inserted directly. Then, these values are assumed to be constant for all related calculations no matter what wavelength was specified. Apparently, in this way no dispersion is taken into account.
Moreover, a material ID can be assigned. While entering an ID name, Unigit checks the color table (see section 3.2) for this name and if being found presents the color assigned to it.
If you pick the file input, the index editor will have the look depicted in Fig. 65.
Fig. 65: Refraction input via nk-file selection
Here, the complete path name of the file with the required index data has to be specified. This can either be done by typing the pathname into the corresponding field (file location) or by clicking the file request button (marked by “…”). In the letter case a file selection box pops up and one has to make a choice. Of course, the file location is not fixed. However, it is recommended to use the folder "...\Unigit\NKData" that is generated during the installation of the UNIGIT code. Basically, the file extension "*.nk" is preferred. The Unigit installation comes with a couple of *.nk example files. Feel free to complete this library according to your needs.
After having specified the n&k file, the data are loaded and shown in a diagram (n red & k green). Alternatively, the n/(1-n) presentation can be chosen for EUV or x-ray materials by checking the corresponding box. Concurrently, the wavelength range as read from the file is given (xmin & xmax). It is possible now to zoom in by changing these values.
Furthermore, it is possible to connect a n&k file directly with a material ID. This can be done by replacing the comment line (first line of the file) with the code word "color" followed by a colon and the material ID name (see example below in Fig. 66). Then, when the n&k file will be used somewhere in the stack, Unigit checks the comment line, when identifying a material ID compares it with the colour table and when successful assigns a colour to it.
Fig. 66: n&k file listing with material ID for color coding (indicated by key word "color:")
Eventually, the refractive index can be defined by means of a certain dispersion formula. Then, the input mask looks like shown in Fig. 67.
Fig. 67: Refraction input via dispersion formula
Depending on the selected dispersion formula, the coefficients n1 thru n3, n4 or n5 as required by the related dispersion formula have to be entered. Make sure that the coefficients are related to the wavelength as given in microns rather than nano-meter, Angstrom or other length measures. Another possibility is to select a certain coefficient set from the combination field. In addition, once the coefficients are entered, the present coefficient set can be saved. In order to be able to recall the set properly, a name has to be entered in the select box. Then, it is available under this name for future operations. If it is not needed anymore, it should be deleted again. The coefficient information is stored in one file per dispersion formula (with the related file name). These files are also located in the folder "...\Unigit\NKData" and can be identified by the file extension ".nkk".
A list of the available dispersion formulas is shown below:
Unigit project files have been introduced to facilitate the organization of complex modeling projects as well as to give some support in retrieving and reconstructing simulations dated back some time. Concurrently, it provides an appropriate mean to avoid time consuming reruns of the UNIGIT solver in order to obtain the results in a different output format for the same application example. Suppose for instance, you have calculated the diffraction efficiencies for a complex 2D example that took several hours. Later, it turns out that you also need the phase information. Then, it would have been a good idea to activate the project file generation in the first run (see section 2.5.5).
In the grating stack tab (section 2.4), Unigit project files can be loaded instead of stack files (see Fig. 68). They possess the extension “*.UPR”.
Fig. 68: Selection of an Unigit project file
After selecting an UPR file, UNIGIT switches from its regular mode into the project retrieval mode. This becomes obvious by two features:
First, the group in the upper right corner changes its name from “Stack” to “Project” and secondly, the START button changes its name into “Extract Results”. In addition, the buttons in the project control group (middle right) are enabled (see Fig. 69).
Fig. 69: Appearance of the central control board in project retrieval mode
The input information is simply retrieved by clicking the button SET INPUT in the group “Project Control”. Then, all input masks such as “Lambda”, “Truncation”, “Theta_i” and “Phi_i” are updated with the original state used to generate the active project file. Likewise, the loop setting is updated along with the associated start, stop and step parameters.
The retrieval of the original stack information is a two-step procedure. In the first step, the stack information is retrieved and saved to a file by means of the GET STACK button. To this end, a file name has to specified by means of the output editor (see section 7.3). After successful operation, the SET STACK button is enabled.
In the second step, the stack file can be set as active stack file and the basic operation mode of Unigit can be switched back to regular by clicking the SET STACK button. Concurrently, Unigit identifies whether the stack file is a valid Unigit format and issues an error message if this is not the case.
Another very important functionality of UNIGIT’s project retrieval mode is the generation of arbitrary result information from a given project file. This is simply done by clicking the EXTRACT RESULTS button. The way how the output is organised has to be set in exactly the same way as for the regular mode. Again, this is done by means of the output editor (see section 7.1) in exactly the same way as for the regular mode. Actually, one will see only subtle change in appearance when starting the output editor (described elsewhere). In addition, some options will be disabled (output only in one file). Analogously, either single files (one for each diffraction order), one big file (all in one) or no file meaning the output is displayed in a DOS window can be generated. The essential difference is that the information is retrieved from a sort of archive (UPR file) instead of being generated by a solver. Thus, it is much faster. Of course, all on board features for data exploration, i.e., starting a notepad to display the ASCII formatted result files or the diagram feature can be applied the usual way (see section 2.5).
All Unigit computation kernels can be run from command line skipping the GUI. In order to do so, run a cmd window, change to unigit installation folder and call the unigit exe you want to run along with 3 or 5 parameters. The parameters are:
The parameter passing is required for the GUI for looping and parallelization. All unigit kernels are controlled by the information in unigit.ctr (it is hard coded). It has to be in the same folder as the exe. The unigit.ctr file is a sort of pointer to the files that control the unigit run. It contains only three lines with the following meaning:
The lines of the input control file have the following meaning:
The lines of the output control file have the following meaning:
Basically, Unigit offers two different options for the calculation of the diffraction angles. The first quick option can be done upfront and does not need to run the RCWA- or C-method computation kernels. It can be launched by clicking the button SHOW ANGLES. The results are shown immediately in a Notepad window. An example is inserted in Fig. 9 for a dielectric grating (nsubstrate = 1.5) with pitch = 1 micron at l = 0.5 and AOI = 45°.
Fig. 70: Presentation of diffraction angles
In the second option, the angular information is a by-product of a full computation run. In order to access it, one has to check the “Diffraction Angles” box in the Output Control Tab (see section 2.5.4).
The angles are defined according to Fig. 71. The polar angles q are measured between the normal axis z and the incident or diffracted ray. The azimuthal angles j are measured between the projection of the ray into the x-y plane and the x-axis.
Fig. 71: Definition of the incidence and diffraction angles in Unigit
/1/ M.G. Moharam, D.A. Pommet and E.B. Grann: “Stable implementation of the rigorous coupled wave analysis for surface-relief gratings: enhanced transmittance matrix approach”, J. Opt. Soc. Am. A 12 (1995), pp. 1077-1086.
/2/ Lifeng Li, “Multilayer modal method for diffraction gratings of arbitrary profile, depth, and permittivity,” J. Opt. Soc. Am. A 10 (1993), pp. 2581-2591.
/3/ D. Agassi and T.F. George, “Convergent schema for light scattering from an arbitrary deep metallic grating,” Phys. Rev. B 33 (1986), pp. 2393-2400.
/4/ Lifeng Li, “Formulation and comparison of two recursive matrix algorithms for modeling layered diffraction gratings,” J. Opt. Soc. Am. A 13 (1996), pp. 1024-1035.
/5/ Lifeng Li, “Use of Fourier series in the analysis of discontinuous periodic structures,” J. Opt. Soc. Am. A 13 (1996), pp. 1870-1876.
/6/ Lifeng Li, “New formulation of the Fourier Modal Method for crossed surface-relief gratings,” J. Opt. Soc. Am. A 14 (1997), pp. 2758-2767.
/7/ P. Lalanne, “Improved formulation of the coupled wave method for two-dimensional gratings,” J. Opt. Soc. Am. A 14 (1997), pp. 1592-1598.
/8/ J. Chandezon, D. Maystre and G. Raoult, “A new theoretical method for diffraction ratings and its numerical application,’’ J. Opt. (Paris) 11, 235–241 (1980).
/9/ L. Li, J. Chandezon, G. Granet, and J.-P. Plumey, “Rigorous and efficient grating analysis method made easy for optical engineers,” Appl. Opt. 38, 304-313 (1999).
/10/ J. Bischoff, “Improved diffraction computation with a hybrid C-RCWA method,” Proc. SPIE 7272, part 2 (2009).
See e.g. http://www.osires.biz/page6.php - reference #5
AOI - Angle of Incidence
AR - Anti Reflective
BARC - Bottom Anti Reflective Coating
CCB - Central Control Board
CD - Critical Dimension
CM - Coordinate Transformation Method (a.k.a. C-method)
GUI - Graphical User Interface
PR - Photo resist
RCWA - Rigorous Coupled Wave Approach
RF - Rayleigh-Fourier (Method)
TE - Transverse Electric
TM - Transverse Magnetic
1D - one-dimensional
2D - two-dimensional
3D - three-dimensional
The project retrieval mode is activated when loading a project file instead of a stack file. In the output editor, this becomes visible by the name change from “Project File” (compare section 7.1) to “Stack File” (see figure below).
<![if !vml]><![endif]><![if !vml]><![endif]>
In case you want to retrieve the stack file from a Unigit project file (see
section 8.3), you have to check this box and
enter a file name where to save the stack information to. The default extension
is the standard “.ust” if not specified otherwise.
<![if !supportFootnotes]><![endif]> it should be noted that it does make sense to choose the same numbers for parameter 2 & 5