RP Photonics
Modeling & Design Software
Technical consulting services on lasers, nonlinear optics, fiber optics etc.
Profit from the knowledge and experience of a top expert!
Powerful simulation and design software.
Make computer models in order to get a comprehensive understanding of your devices!
Success comes from understanding – be it in science or in industrial development.
The famous Encyclopedia of Laser Physics and Technology – available online for free!
The ideal place for finding suppliers for many photonics products.
powerful tools for efficient laser development and laser science
RP Fiber Calculator is a convenient tool for calculations on optical fibers.
RP Fiber Power is an extremely flexible tool for designing and optimizing fiber devices.
RP Resonator is a particularly flexible tool for laser resonator design.
RP ProPulse can simulate the pulse evolution e.g. in mode-locked lasers and sync-pumped OPOs.
RP Coating is a particularly flexible design tool for dielectric multilayer systems.
RP Q-switch can simulate the power evolution in Q-switched lasers.
Most of our software products support a powerful script language, which gives you an extraordinary degree of flexibility.
Competent technical support is a key quality associated with software from RP Photonics.
RP Photonics has distributors in various countries.
The RP Photonics Software News keep you updated on our developments and give the users additional interesting hints.
Here you can make inquiries e.g. concerning technical details, prices and quotations.
en | de

# RP Coating – Advanced Software forDesigning Optical Multilayer Structures

## Demo File: Bragg Mirror

Here, we analyze the properties of a simple Bragg mirror structure, containing 8 pairs of layers with quarter-wave thickness.

We first discuss the script code describing that structure – it is fairly simple:

```d_units: nm
l_units: nm

l_Bragg := 1000  { 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
```

We first generate a few outputs in text form, which will be displayed in the Output area of the program window:

```d_tot := get_d(0)  { total thickness }
lambda_t := 0.9 * l_Bragg  { test wavelength }
show "lambda_t: ", lambda_t:f0:"nm"
show "d_tot:    ", d_tot:f0:"nm"
show "R:        ", 100 * R(lambda_t):f0:"%"
show "T_g_r:    ", T_g_r(lambda_t):d3:"s"
show "GDD_r:    ", GDD_r(lambda_t) / fs^2:f0:"fs^2"
```

Next, we make a diagram showing reflectivity profiles for normal incidence and angled incidence with s and p polarization:

```diagram 1:

"Reflectivity Profile"

x: 600, 1400
"wavelength (nm)", @x
y: 0, 100
"reflectivity (%)", @y
frame
hx
hy
legpos 420, 150

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

f: 100 * R_s(x, 20 deg), "20 deg s-polarized",
color = red, width = 1, style = dashed

f: 100 * R_p(x, 20 deg), "20 deg p-polarized",
color = red, width = 1, style = dotdashed
```

When executing the script, we get the following:

A second diagram is a color diagram, showing how the reflectivity spectra vary with the angle of incidence for p polarization:

```diagram 2:

"Reflectivity for Different Angles of Incidence"
"(for p polarization)"

x: 600, 1400
"wavelength (nm)", @x
y: -90, +90
"angle of incidence (°)", @y
frame
hx
hy

cp: color_I(R_p(x, y * deg))
```

A custom-defined color scale has been used, based on RGB color values for a few intensity levels, which are then interpolated.

Two more diagrams, not shown here, contain plots of the group delay and the group delay dispersion as functions of the wavelength.

The next diagram shows how the optical field intensity varies within the mirror structure:

Next we make a color diagram showing the field penetration at different wavelengths. For better orientation, we also show the layer boundaries:

```diagram 6:

"Field Penetration"

x: 700, 1300
"wavelength (nm)", @x
y: -500, +3500
"depth in the mirror structure (nm)", @y
frame

! begin { show the color scale on the right side of the coordinate system }
var x1, x2;
x1 := CS_x2 + 0.02 * (CS_x2 - CS_x1);
x2 := CS_x2 + 0.04 * (CS_x2 - CS_x1);
for y := CS_y1 to CS_y2 step (CS_y2 - CS_y1) / 500 do
begin
setcolor(color_I((y - CS_y1) / (CS_y2 - CS_y1)));
line(x1 + i * y, x2 + i * y);
end;
setcolor(black);
end

! (set_dir(1); R(lambda_t))

cp: color_I((R(x); E2(y) / 4))  { color plot }

; Show the layer boundaries:
f: 0
f: get_z(j), style = solid, color = lightgray,
for j := 2 to nolayers()
f: d_tot

"substrate", 150, (-200)c
"superstrate", 150, (d_tot + 200)c
```

Finally, we want to see how the reflectivity profile evolves during growth of the structure. This requires a little script programming: we need to save the original thickness values and vary them during the plot:

```diagram 7:

"Development of Reflectivity During Fabrication"

x: 600, 1400
"wavelength (nm)", @x, color = labelgray
y: 0, get_d(0)
"thickness (nm)", @y, color = labelgray
frame

; Save thickness values in an array:
N := nolayers()
defarray d[1,N]
calc
for j := 1 to N do d[j] := get_d(j)

set_d_g(d) :=
{ set the layers for growth up to a total thickness d }
begin
var d_tot;
d_tot := 0;
for j := 1 to N do
begin
var d_j;
d_j := minr(d[j], d - d_tot);  { thickness of the layer }
set_d(j, d_j);
inc(d_tot, d_j);
end;
end

d_l := -1  { last d value set }
R_g(l,d):=  { reflectivity for a total growth thickness d }
begin
if d <> d_l
then begin
set_d_g(d);
d_l := d;
end;
R(l);
end

cp: color_I(R_g(x,y))

; Indicate layer boundaries:
f: get_z(j), color = gray, style = dashed, for j := 2 to N
```

When only the first two layers are grown (bottom part), we get a weak but broadband reflection. Further layers increase the reflectivity, but only in a limited bandwidth.

You can see that with a few lines of script code one can create all sorts of diagrams – not only a few types envisaged by the software developer. Of course, you can use the technical support if you need some hints on how to make a new type of diagram.

## Using a Custom Form

For this demo file, we also have a version with a custom form. Here you see a screenshot:

In the following, you see the beginning of the code (contained in the script) which defines the custom forms:

```Custom form:
--------------------------------------------------------------
\$font: "Arial", bold, size = 24
Bragg Mirror
\$font: "Courier New", size = 11, space = 2.1
\$def pwidth := 505
\$box "Inputs", size = (pwidth, 0):
Material 1:             ##################
\$input (combobox: "SiO2", "TiO2", "HfO2", "ZrO2") material1\$
Material 2:             ##################
\$input (combobox: "SiO2", "TiO2", "HfO2", "ZrO2") material2\$
Bragg wavelength:       #############
\$input l_Bragg_m:d6:"(n)m", min = 100e-9, max = 10e-6
Number of layer payers: #############
\$input N_Bragg:f0, min = 0, max = 1000
```

This is what is needed to define the heading and the first four input fields.

Anyway, using such a form is very simple. You just insert the input values into the corresponding fields and “execute” the form (e.g. with the F8 button). Then the calculations are done, some calculated values are displayed in the gray output fields, and there's also some graphical output depending on the form settings.