Software > RP Coating > User interface

RP Coating – Advanced Software for
Designing Optical Multilayer Structures

The Basic Concept of the User Interface

This software can be controlled with simple forms, where one just enters a couple of input parameters, start the calculation and obtains various outputs:

• Some numerical output data can be displayed in form fields and in the output area on the right side.
• In the form, there can be even graphical displays, e.g. colored bars.
• Further, there can be multiple graphical diagrams for showing things like reflection spectra.

See an example for such a form (a demo file delivered with the software), which can be used for designing anti-reflection coatings. You simply enter the requirements (up to 3 target wavelengths, a bandwidth, angle of incidence, polarization) in addition to some structural parameters (chosen materials, number of layers etc.) and a few numerical parameters (number of Monte-Carlo trials):

It is important to note that the forms and the underlying calculations are not hard-coded. You obtain script files, i.e., text files which define a multilayer structure, all the calculations and the generated graphical diagrams, and (optionally) a custom form. You can modify such scripts such they meet your specific needs. The user interface of the software provides powerful editors and a lot of additional helpful features for modifying such scripts or developing new scripts.

Scripting gives you enormous flexibility. With that, you can implement even most sophisticated models; you can even do full-blown programming. Competing programs which do not offer scripting cannot compete with RP Coating in terms of flexibility:

• In RP Coating, the coating structure does not have to be entered as a table (which could be tedious), but can be constructed with loops, for example, where layer thickness values can be varied systematically with mathematical expressions (see below). One can easily combine different parts of the overall design – for example, a Bragg mirror, a spacer, and a few additional top layers. The overall design can be parametrized easily.
• RP Coating allows you to do optimizations with arbitrary mathematical forms of the figure-of-merit function. Other programs normally only allow one to enter parameters of a predetermined figure-of-merit function.
• You can easily implement additional calculations – for example, average quantities over some angular ranges or check effects on ultrashort pulses.
• You can create essential any kinds of graphical plots for analyzing the results – not just choose from a defined set of diagrams.
• You can copy & paste within and between scripts, which is much simpler than going through many forms and entering inputs again.

Note that competing software products usually offer only hard-coded standard forms, which you cannot adapt to your needs. You just have to hope that they will provide everything which you will need.

The Script Language

The script language of RP Coating is very powerful. Each input script can contain

• the definition of a multilayer structure,
• any additional calculations for obtaining the quantities of interest,
• the definition of multiple graphical diagrams,
• further code for exporting output data to files or importing data (e.g. measured reflection spectra) from files, and
• a custom form for easy handling.

Instead of using a custom form, you can also simply define the input parameters within the script. However, it is often preferable to make a custom form. For example, it easily allows you to switch between different parameter sets, which you can save in files.

Of course, you can store frequently used script parts in external files and easily call them in your main script.

The following code snippets show you that the script language is easy to use.

Simple Bragg Mirror

The first example shows how a simple Bragg mirror is defined:

l_Bragg := 1000 nm  { Bragg wavelength }
N_Bragg := 8  { number of layer pairs }

beam from superstrate
substrate: BK7
for j := 1 to N_Bragg do
begin
  * SiO2, d = l/4 at l_Bragg
  * TiO2, d = l/4 at l_Bragg
end
superstrate: air

Chirped Mirror

A second example shows the definition of a chirped mirror, where all layer thickness values vary systematically within the coating:

l_Bragg0 := 1000 nm  { Bragg wavelength in the middle }
dl := 5 nm  { change of Bragg wavelength with each layer pair }
N_Bragg := 8  { number of layer pairs }
l_B(j) := l_Bragg0 + (j - N_Bragg / 2) * dl  { Bragg wavelength for layer pair j }
d_SiO2(j) := (var l; l := l_B(j); l / 4 / n_SiO2(l))
d_TiO2(j) := (var l; l := l_B(j); l / 4 / n_TiO2(l))

beam from superstrate
substrate: BK7
for j := 1 to N_Bragg do
begin
  * SiO2, d = d_SiO2(j)
  * TiO2, d = d_TiO2(j)
end
superstrate: air

You see that it is straight-forward to implement different types of chirps, add some more layers, etc. That flexibility is usually not obtained for competing products.

Numerical Optimization

Here is a little code for a numerical optimization:

l_HR := 1064  { HR wavelength }
l_HT := 808   { HT wavelength }
FOM():= { merit function }
  sqrt(sum(d := -20 to +20 step 5, T(l_HR + d)^2)
      +sum(d := -20 to +20 step 5, R(l_HT + d)^2))

optimize coating for minimum of FOM()

The defined merit function would be zero for a mirror with vanishing transmission around 1064 nm and vanishing reflectivity around 808 nm – that is the design target of a dichroic mirror used for injecting pump light into a Nd:YAG laser. The command “optimize” modifies the structure such that the value of that merit function is minimized.

Displaying a Reflection Spectrum

Finally, we show a little code for showing a reflection spectrum:

diagram 1:

"Reflectivity Profile"

x: lambda_min, lambda_max
"wavelength (nm)", @x
y: 0, 100
"reflectivity (%)", @y
frame
hx
hy

f: 100 * R(x),
  color = red, width = 3

Script Editors

For editing script code, the software offers powerful editors and related tools. A screen shot shows an editor:

Some great features of such editors:

• Multilevel undo/redo functionality
• Syntax highlighting: recognized command or function names, keywords, comments etc. are shown with different colors. That makes it easier to understand the structure.
• Parameter hints: if you type in a function name followed by a parenthesis, the editor displays information on the required parameter list. That way it becomes much simpler to utilize the hundreds of supported functions.
• Syntax check: you can quickly have the syntax of a script checked without executing it.
• Code snippets library: you can easily insert certain frequently used parts of code into your script. (See the screen shot below.) Users can create own code snippets as an extension for that library.

Graphical Output

Your script can define several diagrams for visualizing the results of the calculations. Examples are shown on the pages for various example cases. Each diagram is shown in a separate window. Below you see an example of such a graphics window, showing what optical intensities occur in a Bragg mirror for different wavelengths.

Those graphics windows have plenty of convenient features:

• measure positions and distances using one or two cursors
• save the graphics in GIF or PNG format
• export numerical data
• copy the graphics to the Windows clipboard
• recall the graphics from the last calculation run (e.g. from a slightly modified coating design), so that you can clearly see any differences
• browse in multiple versions of a diagram

Comprehensive Documentation

RP Coating comes with very well worked out documentation, which allows you to have a quick start and work efficiently even when doing sophisticated modeling:

• There is a manual in PDF format, explaining in detail (on about 40 pages) the principles of the physical model, the user interface, the script language, etc.
• The context-sensitive interactive help function is even more comprehensive. See the screen shot below to get an impression.

Technical Support

Any remaining problems can be addressed with the technical support. We make sure that any problems you may have will soon be solved.