**2.Plane Waves > 3. Optical Modulation**

**2.Amplitude modulation**

Author: Daniel Töyrä

Amplitude modulation is used to encode information as a time dependent amplitude of a carrier wave. The technique is most famously known for being used for radio broadcasting.

When we use photo diodes to measure a laser field, power is what we measure. In the field of gravitational waves the carrier frequency is way to high for a photo diode to measure sub-period power, thus, the measurable quantity is "slowly" varying amplitude modulation. Both phase and frequency modulation need to be converted into amplitude modulation to be detectable.

This session will introduce the basics of amplitude modulation, and show how we simulate it with FINESSE using the sideband picture.

** Recommended notebooks before you start:**

We recommend that you have looked through introductory notebooks that you find in the folder 01_Introduction before you start this one, or that you have basic experience of IPython/Jupyter Notebooks, PyKat, and Finesse. The link above only works if you started IPython/Jupyter Notebook in the top directory of this course.

**Reading material and references:**

[1] A. Freise, K. Strain, D. Brown, and C. Bond, "Interferometer Techniques for Gravitational-Wave Detection", *Living Reviews in Relativity* **13**, 1 (2010). - Living review article (more like a book) on laser interferometry in the frequency domain for detecting gravitational waves, and FINESSE.

[2] A. Freise, D. Brown, and C. Bond, "Finesse, Frequency domain INterferomEter Simulation SoftwarE". - FINESSE-manual

[3] FINESSE syntax reference - Useful online syntax reference for FINESSE. Also available in the Finesse manual [2], but this online version is updated more frequently.

** After this session you will... **

- be able to use an Electro-Optic Modulator to amplitude modulate an optical field in FINESSE.
- have seen that FINESSE uses the sideband picture to represent amplitude modulated fields.
- be able to tell if the DC-power decreases or not as the modulation index increases for amplitude modulation

Importing PyKat and other Python packages that we need, and setting up how to display figures.

In [2]:

```
import numpy as np # Importing numpy
import matplotlib # For plotting
import matplotlib.pyplot as plt
from pykat import finesse # Importing the pykat.finesse package
from pykat.commands import * # Importing all packages in pykat.commands.
from IPython.display import display, HTML # Allows us to display HTML.
# Telling the notebook to make plots inline.
%matplotlib inline
# Initialises the PyKat plotting tool. Change the dpi value
# to adjust size of figures on your screen.
pykat.init_pykat_plotting(dpi=90)
```

\begin{align}
E(t) = E_0\cos \big( 2\pi f_\mathrm{c} t + \varphi_c \big) \big( 1 + m\sin(2\pi f_\mathrm{m} t + \varphi_\mathrm{m}) \big).
\end{align}

Here, the *modulation frequency* $f_\mathrm{m}$ determines how quickly the amplitude changes, the *modulation index* $m$ determines how large the amplitude fluctuations are, and the *modulation phase* $\varphi_\mathrm{m}$ is a constant phase term of the signal. Note that this equation requires an active element performing the modulation since the amplitude sometimes is larger than the initial carrier amplitude, thus energy must have been added. For passive amplitude modulation, this expression can be used instead

\begin{align}
E(t) = E_0\cos \big( 2\pi f_\mathrm{c} t + \varphi_c \big) \Big( 1 - \frac{m}{2}\big(1 - \sin(2\pi f_\mathrm{m} t + \varphi_\mathrm{m}) \big) \Big).
\end{align}

For amplitude modulation, the modulation index must be between 0 and 1, where 1 corresponds to the instantaneous amplitude reaching down to zero at the minimum.

In [3]:

```
## Code for showing a phase modulated field ##
# Parameters
# --------------------------------------------------
t = np.linspace(0,1,2048) # Time array
E0 = 1 # Amplitude of the field.
fc = 20 # Carrier freq
phi_c = 0 # Phase of the field
fm = 2 # Phase modulation freq
m = 0.9 # Modulation index [0,1]
phi_m = 0 # Modulation phase
# Computing the fields and signal arrays
# --------------------------------------------------
# Carrier field
E = E0*np.cos(fc*2*np.pi*t + phi_c)
# Signal
x = m*np.sin(fm*2*np.pi*t + phi_m)
# Phase modulated field
E_m = E0*np.cos(fc*2*np.pi*t + phi_c)*(1 - (m/2)*(1-np.sin(fm*2*np.pi*t+phi_m) ))
# Plotting
# --------------------------------------------------
fig = plt.figure(figsize=(10,3))
# Axis for carrier and modulated field
ax = plt.subplot(1,1,1)
p1 = ax.plot(t,E,'0.7', label='$\mathrm{Carrier}\ E_c(t)$')
p2 = ax.plot(t,E_m,'r',label='$\mathrm{Mod. field}\ E_m(t)$')
ax.set_xlabel('t')
ax.set_ylabel('E(t)')
ax.set_title('Amplitude modulation')
ax.set_xlim(-0.01,1.01)
# Second y-axis for signal
ax2 = ax.twinx()
p3 = ax2.plot(t,x,'b', label='$\mathrm{Signal}\ x(t)$')
ax2.set_ylabel('x(t)')
# The legend
plots = p1+p2+p3
labs = [lab.get_label() for lab in plots]
ax.legend(plots, labs, loc=1, fontsize=10)
# Showing figure
plt.show(fig)
```

**Figure.** The figure shows an amplitude modulated field $E_m(t) = E_0\cos\big(2\pi f_\mathrm{c} t + \varphi_c \big) \Big( 1 - \frac{m}{2}\big(1 - \sin(2\pi f_\mathrm{m} t + \varphi_\mathrm{m}) \big) \Big)$ in red, the carrier field $E_c(t) = E_0\cos (2\pi f_\mathrm{c} t)$ in gray, and the signal $x(t) = m \sin(2\pi f_\mathrm{m} t + \varphi_m)$ in blue.

\begin{align}
E_\mathrm{m}(t) = E_0\exp \Big(i\big( 2\pi f_\mathrm{c} t \big) \Big)\Big( 1 - \frac{m}{2}\big(1 - \sin(2\pi f_\mathrm{m} t + \varphi_\mathrm{m}) \big) \Big) ,
\end{align}

where the constant phase term of the carrier $\varphi_c$ has been absorbed into the now complex amplitude $E_0$. By using the Euler identity $\sin(\phi) = \big( \mathrm{e}^{i\phi}-\mathrm{e}^{-i\phi}\big) /2i$, we can write this as

\begin{align}
E_\mathrm{m}(t) =& E_0\mathrm{e}^{2\pi i f_\mathrm{c} t}
\bigg[ 1 - \frac{m}{2} - \frac{im}{4}
\Big( \mathrm{e}^{i ( 2\pi f_\mathrm{m} t + \varphi_\mathrm{m} )} -
\mathrm{e}^{-i ( 2\pi f_\mathrm{m} t + \varphi_\mathrm{m})}
\Big)
\bigg] \\
=& a_0 \mathrm{e}^{2\pi i f_c t} + a_- \mathrm{e}^{2\pi i f_- t} + a_+ \mathrm{e}^{2\pi i f_+ t} ,
\end{align}

**Figure.** The figure shows an amplitude modulated field in the frequency domain, where the carrier is in read and the sidebands are in blue.

*Electro-Optic Modulator* (EOM, keyword `mod`

) to show how the amplitude of the carrier and the sidebands varies with the modulation index $m$. The setup can be seen in the figure below. We use *amplitude detectors* (keyword `ad`

) to look at the amplitude of the frequency components. Amplitude detectors does not exist, but a nice property of numerical models is that we can make impossible "measurements".

**Figure.** The figure shows the setup used in this session. The component names match the FINESSE model created below.

We start by building the base model:

In [4]:

```
basekat = finesse.kat() # Initialising Finesse
basekat.verbose = False # Tells Finesse to talk less
# Finesse code
code = """
## The optical system ##
l laser 1 0 n0 # 1 W laser, 0 wavelength offset (using default 1064nm)
s s1 1 n0 n1 # Space from laser to mirror (1 m)
mod eom 1k 0.3 1 am 0 n1 n2 # Modulator (f=1 kHz, m=0.3, 1 sideband pair,
# amplitude modulation, 0 degree mod. phase)
s s2 1000 n2 n3 # Space from modulator to output (1 m)
"""
# Parsing the Finesse code
basekat.parseKatCode(code)
```

Now we add the amplitude detectors, and specify what we want to simulate, and run the simulation:

In [5]:

```
kat1 = deepcopy(basekat)
code = """
## Detectors ##
ad car 0 n3 # Ampitude dector, carrier (0 freq offset)
ad sb 1k n3 # Ampitude dector, upper sideband (1 kHz offset)
## Simulation Instructions ##
xaxis eom midx lin 0 1 200 # Varying the modulation index between 0 and 1.
yaxis abs # Returns magnitudes of detector outputs
"""
# Parsing the code and running the simulation
kat1.parseCommands(code)
out1 = kat1.run()
```

Plotting the simulation results:

In [6]:

```
# Only plotting the
fig1 = out1.plot(title = 'Amplitude of freq. components vs. modulation index',
ylabel='Amplitude $[\sqrt{W}]$',
xlabel='Modulation index')
```

** Answer: **

In [ ]:

```
```

** Answer: **

The important parts to remember here are

- that we need to use the lower sideband as well (which was excluded in the example above)
- that amplitude in Finesse is in the unit $\sqrt{\mathrm{W}}$
- how to compute the DC-power, see the beginning of section 4 in the living review article [1]

We also add a photo diode to detect the power to see if there is a difference compared to square the absolute sum of amplitudes.

In [7]:

```
# Copying our core model
kat2 = deepcopy(basekat)
# Adding detectors and instructions
code = """
## Detectors ##
ad car 0 n3 # Ampitude dector, carrier (0 freq offset)
ad up 1k n3 # Ampitude dector, upper sideband (1 kHz offset)
ad low -1k n3 # Ampitude dector, lower sideband (-1 kHz offset)
pd pow n3 # Photo diode, detecting DC-power
## Instructions ##
xaxis eom midx lin 0 1 200 # Sweeping the modulation index between 0 and 1
yaxis abs # Returns absolute values of the detectors
"""
# Parsing the code and running the simulation
kat2.parseKatCode(code)
out2 = kat2.run()
```

In [8]:

```
# Resulting fields and power
# ----------------
# Carrier only
P_c = out2['car']**2
# With one sideband pair
P_tot = (out2['car']**2 + out2['up']**2 + out2['low']**2)
# With only the sidebands
P_sb = (out2['up']**2 + out2['low']**2)
```

Plotting the results:

In [9]:

```
# Plotting
# ---------
fig2 = plt.figure(figsize=(10,4))
ax = plt.subplot(1,1,1)
ax.plot(out2.x, P_c, label='Carrier')
ax.plot(out2.x, P_tot, label='Carrier and sidebands')
ax.plot(out2.x, P_sb, label = 'Only sidebands')
ax.plot(out2.x, out2['pow'], 'k--', label='Photo diode')
# Labels and legend
ax.set_title('Power conservation of EOM performing amplitude modulation')
ax.set_ylabel('Power [W]')
ax.set_xlabel('Modulation index')
ax.legend(loc=1)
plt.show(fig2)
```

In this session we have:

- used an electro-optic modulator to amplitude modulate a laser field
- seen that an amplitude modulated field can be described by adding two sidebands around the carrier
- investigated what happens with the total DC-power as the modulation index grows