Basic implementation

# See http://mitrocketscience.blogspot.com/2018/11/automatic-mulit-threading-with-python.html

# Also notice that I've installed Intel's mkl as suggested at
# https://www.intel.com/content/www/us/en/developer/articles/technical/using-intel-distribution-for-python-with-anaconda.html

import os

NTHREADS = '12' # Value set as string

# Export system variables before loading numpy
for i in ['OMP_NUM_THREADS', 'OPENBLAS_NUM_THREADS', 'MKL_NUM_THREADS']:#,
          #'VECLIB_MAXIMUM_THREADS', 'NUMEXPR_NUM_THREADS']:
    os.environ[i] = NTHREADS

import numpy as np

# Defining two big matrices for testing

matrix_shape = (2048, 2048)
a = np.random.random(matrix_shape) + 1j * np.random.random(matrix_shape)
b = np.random.random(matrix_shape) + 1j * np.random.random(matrix_shape)

np.show_config()

blas_mkl_info:
    libraries = ['mkl_rt']
    library_dirs = ['C:/Users/Anderson/anaconda3\\Library\\lib']
    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]
    include_dirs = ['C:/Users/Anderson/anaconda3\\Library\\include']
blas_opt_info:
    libraries = ['mkl_rt']
    library_dirs = ['C:/Users/Anderson/anaconda3\\Library\\lib']
    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]
    include_dirs = ['C:/Users/Anderson/anaconda3\\Library\\include']
lapack_mkl_info:
    libraries = ['mkl_rt']
    library_dirs = ['C:/Users/Anderson/anaconda3\\Library\\lib']
    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]
    include_dirs = ['C:/Users/Anderson/anaconda3\\Library\\include']
lapack_opt_info:
    libraries = ['mkl_rt']
    library_dirs = ['C:/Users/Anderson/anaconda3\\Library\\lib']
    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]
    include_dirs = ['C:/Users/Anderson/anaconda3\\Library\\include']

# How long does it take to calculate the dot product?
%timeit np.dot(a, b)

1.27 s ± 4.66 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit np.fft.fft(a)

37.1 ms ± 449 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

%timeit np.fft.ifft(a)

38.9 ms ± 590 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

%timeit -n 100 a * b

17.3 ms ± 1.18 ms per loop (mean ± std. dev. of 7 runs, 100 loops each)

import pyfftw

pyfftw.config.NUM_THREADS = 1

%timeit -n 100 pyfftw.interfaces.numpy_fft.fft(a)

63.3 ms ± 1.4 ms per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit np.dot(a, b)

322 ms ± 8.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

f"An improvement of {(1-322/1270) * 100:.2f}%"

'An improvement of 74.65%'

%timeit np.fft.fft(a)

33.4 ms ± 620 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

f"An improvement of {(1-33.4/37.1) * 100:.2f}%"

'An improvement of 9.97%'

%timeit np.fft.ifft(a)

35.1 ms ± 337 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

f"An improvement of {(1-35.1/38.9) * 100:.2f}%"

'An improvement of 9.77%'

%timeit -n 100 a * b

13.2 ms ± 242 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

f"An improvement of {(1-13.2/17.3) * 100:.2f}%"

'An improvement of 23.70%'

pyfftw.config.NUM_THREADS = pyfftw.config.multiprocessing.cpu_count()

%timeit -n 100 pyfftw.interfaces.numpy_fft.fft(a)

46.4 ms ± 259 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

f"An improvement of {(1-46.4/63.3) * 100:.2f}%"

'An improvement of 26.70%'

Numba

Numba is a python library that often speeds up numerical calculations by using just-int-time compilation and avoiding the overhead of dynamic types in python scripts. Here we install it and perform some benchmarks. Unfortunately it does not support ffts, which would be a significant improvement for algorithms as split-step propagation method.

!pip install numba

Requirement already satisfied: numba in c:\users\anderson\anaconda3\lib\site-packages (0.54.1)
Requirement already satisfied: llvmlite<0.38,>=0.37.0rc1 in c:\users\anderson\anaconda3\lib\site-packages (from numba) (0.37.0)
Requirement already satisfied: numpy<1.21,>=1.17 in c:\users\anderson\anaconda3\lib\site-packages (from numba) (1.20.3)
Requirement already satisfied: setuptools in c:\users\anderson\anaconda3\lib\site-packages (from numba) (58.0.4)

from numba import jit, njit, objmode

%timeit np.dot(a, b) + np.exp(a * b **2)

586 ms ± 8.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

@njit
def example():
    return np.dot(a, b) + np.exp(a * b **2)

%timeit example()

396 ms ± 11.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

f"An improvement of {(1-396/586) * 100:.2f}%"

'An improvement of 32.42%'

def example():
    np.fft.fft2(a * np.conj(b))*np.conj(b)
    np.fft.ifft2(a * b)*b
    return 0

%timeit example()

336 ms ± 3.62 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

"""
Since numba does not have native support for fft,
there is a workaround suggested at
https://github.com/numba/numba/issues/5864#issuecomment-690838747
"""

@jit(nopython=True)
def example2():
    d = a * np.conj(b)
    with objmode(d='complex128[:]'):
        d = np.fft.fft2(d)        
    d = d * np.conj(b)
    
    d = a * b
    with objmode(d='complex128[:]'):
        d = np.fft.ifft2(d)        
    d = d * b    
    return 0

%timeit example2()

277 ms ± 8.44 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

f"An improvement of {(1-277/336) * 100:.2f}%"

'An improvement of 17.56%'

@jit()
def example3():
    np.fft.fft2(a * np.conj(b))*np.conj(b)
    np.fft.ifft2(a * b)*b
    return 0

%timeit example3()

C:\Users\Anderson\AppData\Local\Temp/ipykernel_22088/3408064900.py:1: NumbaWarning: 
Compilation is falling back to object mode WITH looplifting enabled because Function "example3" failed type inference due to: Unknown attribute 'fft2' of type Module(<module 'numpy.fft' from 'C:\\Users\\Anderson\\anaconda3\\lib\\site-packages\\numpy\\fft\\__init__.py'>)

File "..\..\..\..\AppData\Local\Temp\ipykernel_22088\3408064900.py", line 3:
<source missing, REPL/exec in use?>

During: typing of get attribute at C:\Users\Anderson\AppData\Local\Temp/ipykernel_22088/3408064900.py (3)

File "..\..\..\..\AppData\Local\Temp\ipykernel_22088\3408064900.py", line 3:
<source missing, REPL/exec in use?>

  @jit
C:\Users\Anderson\anaconda3\lib\site-packages\numba\core\object_mode_passes.py:151: NumbaWarning: Function "example3" was compiled in object mode without forceobj=True.

File "..\..\..\..\AppData\Local\Temp\ipykernel_22088\3408064900.py", line 1:
<source missing, REPL/exec in use?>

  warnings.warn(errors.NumbaWarning(warn_msg,
C:\Users\Anderson\anaconda3\lib\site-packages\numba\core\object_mode_passes.py:161: NumbaDeprecationWarning: 
Fall-back from the nopython compilation path to the object mode compilation path has been detected, this is deprecated behaviour.

For more information visit https://numba.pydata.org/numba-doc/latest/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit

File "..\..\..\..\AppData\Local\Temp\ipykernel_22088\3408064900.py", line 1:
<source missing, REPL/exec in use?>

  warnings.warn(errors.NumbaDeprecationWarning(msg,

343 ms ± 10.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit example3()

344 ms ± 13.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

f"An improvement of {(1-344/336) * 100:.2f}%"

'An improvement of -2.38%'

Thus, while numba is able to deliver improvements around 20-30%, it’s lack of fft support slows down the computation significantly. In particular the nopython=True option is critical to have significant performance gains, otherwise it can even make the code slower as in the example 3 above.

Tensorflow

Since tensorflow has native support for ffts, some tests were also performed using the code below. I’ve tested it using my GPUless PC and also google colab’s cloud computing service. Since it’s not feasible to show the timeit results inline with so many configurations, the data is summarized at the end.

import tensorflow as tf

import tensorflow.experimental.numpy as tnp
tnp.experimental_enable_numpy_behavior()

# Gerando matrizes equivalentes ao teste anterior, no tensorflow

matrix_shape = (2048, 2048)

a = tf.random.uniform(matrix_shape, dtype=tf.dtypes.float64)
b = tf.random.uniform(matrix_shape, dtype=tf.dtypes.float64)

c = tf.cast(a, tf.dtypes.complex128) + 1j * tf.cast(b, tf.dtypes.complex128)
d = tf.cast(b**2 - a**2, tf.dtypes.complex128) + 1j * tf.cast(a*b, tf.dtypes.complex128)

a = c
b = d

# Shows if a gpu is available
tf.config.list_physical_devices()

tf.debugging.set_log_device_placement(True)

# Example 0
%timeit tf.experimental.numpy.dot(a, b)

tf.debugging.set_log_device_placement(True)

# Example 1
%timeit tf.signal.fft2d(a)

tf.debugging.set_log_device_placement(True)

# Example 2
%timeit tf.signal.ifft2d(a)

tf.debugging.set_log_device_placement(True)

# Example 3
%timeit -n 100 a * b

tf.debugging.set_log_device_placement(True)

# Example 4
%timeit tf.signal.fft( a * b) * b * tf.signal.ifft( a * b) * b

import pandas as pd

df = pd.DataFrame()

#times in ms

df['Home (CPU)'] = [783, 140, 173, 14.9, 218]
df['Colab (CPU)'] = [3460, 477, 605, 18.1, 503]
df['Colab (GPU-fastest)'] = [1.23, 0.266, 3.51, 0.093, 2.94]
df['Colab (GPU-slowest)'] = [1.23*14.63, 0.266*1515, 3.51, 0.093*97.98, 2.94]

df['Colab GPU % improvement'] = df['Colab (CPU)']*2./(df['Colab (GPU-fastest)']+df['Colab (GPU-slowest)']) * 100

df

It’s worth to mention that the CPU available on colab performs slower than the one I have at home, but tensorflow shows a significant performance improvement when executed on the GPU. Also, when executing locally it can be seen that tensorflow code is very optimized to use all cores. While this strategy may not be optimal for a processor with a few cores, it’s certainly interesting for GPUs with their massive number of parallel processing cores.

Something to be aware of is that timeit on colab works differently, such that it reports the best time, while on jupyter lab it reports the mean time. When the calculation can buffer some sections of the calculus for speedup, the reported value may be an optimistic view of the true computation time. Is it time for a GPU?

Also, the timeit results from colab are inconsistent. Depending on the run, the values may become significantly larger or smaller. However, it seems reasonable to expect at least one order of magnitude speedup factor when using tensorflow+gpu for these calculations. However it should be possible to speedup up to 4 orders of magnitude, depending on the operations used. This would be very consistent with the performance gains of up to 1000x reported in

https://arxiv.org/abs/2010.08895

https://www.technologyreview.com/2020/10/30/1011435/ai-fourier-neural-network-cracks-navier-stokes-and-partial-differential-equations/

but without the need for NNs to solve these PDEs, but it’s just related with the TF’s improved speed when using gpus.

Pytorch

Notice that pytorch also has a native fft library, and it probably should be interesting to benchmark it as well.

Data analysis and reports

The previous chapter gave an overview of Python and Numpy, which allowed us to learn the language, manipulate data, evaluate and plot functions. In this chapter we will see how to represent data tables in Python, how to save and load data from files and also how to fit the data to theoretical models. Besides Numpy (numeric manipulation) and Matplotlib (plots), we will use other Python libraries as Pandas (tables) and Scipy (data fitting). Later on it will be shown how to use Jupyter notebook to write reports. There is a short description on how to use the Markdown syntax to compose a document and an later there is an overview of syntax to write mathematical expressions.

%pylab inline
import pandas as pd

df = pd.DataFrame()
df['time']     = [1, 2, 3,  4,  5]
df['position'] = [1, 4, 9, 16, 25]
df['velocity'] = [2, 4, 6,  8, 10]

df

df.plot('time', 'position', kind='scatter')
title('Position vs time')
xlabel('Time (s)')
ylabel('Position (m)')
savefig(r'assets\pes_pos_scatter_plot.png')

df['sqrt(t) + 1'] = sqrt(df['time']) + 1

df

df = pd.DataFrame() # Clears df

# x contains 101 equally spaced values from 0 to 15
df['x'] = linspace(0, 15, 101)
df['sin x'] = sin(df['x'])

df.plot('x', 'sin x')
savefig(r'assets\pes_sine_plot.png')

df['A=0.2'] = sin(df['x']) - 0.2 * df['x']
df.plot('x', 'A=0.2')
savefig(r'assets\pes_transcendental_sol_plot.png')

df[abs(df['A=0.2']) < 0.1]

df = pd.DataFrame() # Clears df

df['x'] = arange(1, 11) #Array of integers from 1 to 10=11-1
df['x**2'] = df['x']**2
df['x**3'] = df['x']**3
df['x**0.5'] = df['x']**0.5

df

ax1 = df.plot('x', 'x**2'  , color='red' , kind='scatter')
ax2 = df.plot('x', 'x**0.5', color='blue', kind='scatter',
              ax=ax1)

savefig(r'assets\multiple_scatter_plot.png')

ax1 = df.plot('x', 'x**2'  , color='red' , kind='scatter',
              logx=True, logy=True)
ax2 = df.plot('x', 'x**0.5', color='blue', kind='scatter',
              ax=ax1)

savefig(r'assets\multiple_scatter_plot_logxy.png')

%pylab inline
import pandas as pd
from scipy import optimize

df = pd.DataFrame()

df['x'] = arange(1, 11) #Array of integers from 1 to 10=11-1
df['x**2'] = 0.3 * df['x']**2
df['x**3'] = 5 * df['x']**3
df['x**0.5'] = pi * df['x']**0.5

def power_law(x, A, n):
  return A * x ** n

popt, pcov = optimize.curve_fit(power_law, df['x'], df['x**0.5'])
error = sqrt(pcov.diagonal())
popt, error

(array([3.14159265 0.5       ]), array([3.05923019e-16 5.08058315e-17]))

df2 = pd.DataFrame()

# x contains 101 equally spaced points from 1 to 10
df2['x'] = linspace(1, 10, 101)
# Remember that popt[0] corresponds to A and popt[1] to n
df2['y'] = power_law(df2['x'], popt[0], popt[1])

ax1 = df.plot('x', 'x**0.5', kind='scatter',
              logx=True, logy=True)
ax2 = df2.plot('x', 'y', ax=ax1, legend=False)
savefig(r'assets\scatter_plot_fitting_data.png')

df = pd.DataFrame()
df['Frequency'] = [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000]
df['Amplitude'] = [0.11, 0.32, 0.96, 0.54, 0.31, 0.22, 0.18, 0.15, 0.12, 0.11]

df.T

def ressonant(x, A, wr):
  return 1 / sqrt( 1 + A * (x/wr - wr/x)**2 )

popt, pcov = optimize.curve_fit(ressonant,
                df['Frequency'], df['Amplitude'])
error = sqrt(pcov.diagonal())
print(popt, error)

df2 = pd.DataFrame()
df2['x'] = linspace(100, 1000, 101)
df2['y'] = ressonant(df2['x'], popt[0], popt[1])

ax1 = df.plot('Frequency', 'Amplitude', kind='scatter')
ax2 = df2.plot('x', 'y', ax=ax1, legend=False)
savefig(r'assets\scatter_plot_fitting_resonant_data_attempt1.png')

initial_guess = [100, 300]

popt, pcov = optimize.curve_fit(ressonant,
                df['Frequency'], df['Amplitude'], p0=initial_guess)
error = sqrt(pcov.diagonal())
print(popt, error)

df2 = pd.DataFrame()
df2['x'] = linspace(100, 1000, 101)
df2['y'] = ressonant(df2['x'], popt[0], popt[1])

ax1 = df.plot('Frequency', 'Amplitude', kind='scatter')
ax2 = df2.plot('x', 'y', ax=ax1, legend=False)
title("Signal amplitude after a resonant circuit")
xlabel("Frequency (rad/s)")
ylabel("Amplitude (normalized)")
savefig(r'assets\scatter_plot_fitting_resonant_data_attempt2.png')

plotInitialGuess = True
if plotInitialGuess:
  df2['y'] = ressonant(df2['x'], initial_guess[0], initial_guess[1])
else:
  df2['y'] = ressonant(df2['x'], popt[0], popt[1])

# model(x, parameters separated by commas)
def model(x, A, wr):
  # return y(x) expressed in terms of the fitting parameters
  return 1 / sqrt( 1 + A * (x/wr - wr/x)**2 )

# Initial guess for the parameter values (ordered as in the model)
initial_guess = [100, 300]

popt, pcov = optimize.curve_fit(model,
                df['Frequency'], df['Amplitude'], p0=initial_guess)
error = sqrt(pcov.diagonal())

df2 = pd.DataFrame()
df2['x'] = linspace(100, 1000, 101)

plotInitialGuess = True
if plotInitialGuess:
  df2['y'] = model(df2['x'], initial_guess[0], initial_guess[1])
else:
  df2['y'] = model(df2['x'], popt[0], popt[1])
  # Outputs the best fit params and associated errors
  print("Fit parameters")
  for i, (p, e) in enumerate(zip(popt, error)):
    print('p[%d] =' % i, p, ' +- ', e)

ax1 = df.plot('Frequency', 'Amplitude', kind='scatter')
ax2 = df2.plot('x', 'y', ax=ax1, legend=False)
title("Output signal amplitude")
xlabel("Frequency (rad/s)")
ylabel("Amplitude (normalized)")
savefig(r'assets\scatter_plot_fitting_resonant_data_final.png')

Using the Jupyter notebook for scientific writing

With our previous discussion it is possible to analyze data. But how to write a report? It is possible to use common tools as a word processor, but we also can use our Jupyter notebook to produce reports in PDF format, slideshows and HTML webpages. While the standard PDF output is somewhat limited, it is possible to export to other formats (as LaTex) and edit the result to achieve professional looking documents. This is interesting because the data analysis and its analysis are condensed in the same file, making it easier to correct mistakes during the work. Also, the compatibility means that the document can be exported to a document format commonly used in the publication of scientific documents.

The Jupyter notebook is separated in cells. The default cells are for code, such we can execute portions of code separately and perform exploratory studies. We can add more cells (using the + button close to the save button in the snapshot below), split or join cells (see the Edit menu). However, the Jupyter screenshot below shows a menu where the type of the current cell can be chosen. The Markdown mode is adequate to type descriptive texts and can be placed anywhere within the notebook, such it is possible to mix explanations and the code necessary to achieve the results reported.

Markdown is a simple syntax developed to express document formatting in plain text. It is aimed at being simple and readable, such that it can be learned much more quickly than LaTex for example. Also, an interesting characteristic is that it allows the writer to focus on content instead of text formatting. This document is written using Markdown, and this syntax is recognized by several web tools. For example, to put emphasis in a text block we can write it between single asterisks *text* to obtain the text in italics. Writing between double asterisks around **some text** gives some text in bold. The table below shows some examples of what can be done.

To obtain	type	to get
Italics	*italics*	italics
Bold	**bold**	bold
Inline code	`some code`	some code
Math	$x = \sin\pi/2$
Link	[link label](https://commonmark.org)	link label
Image	{width=40px}

The typing of hypertext becomes reasonably simple using the above syntax, and it can be memorized without too much effort. After you execute the cell, Jupyter notebook will automatically exhibit the formatted output. To use images in your computer as above, remember that it must be sent together with your notebook to be seen by someone else. Images from the web can be shown by using the adequate url. Some will be given later to help in writing mathematical expressions.

Another set of Markdown instructions is to handle sections and blocks of text. Notice that to separate between distinct blocks must be separated by blank lines. Your document can be divided in sections with the syntax below. Up to 6 levels can be used, and using this is interesting because it makes easier to navigate through the PDF and outputs.

# Section

## Subsection

### Subsubsection

To add a quote, use

> quote text

to achieve

quote text

A bullet list can also be written simply by writing the first character of each line as a * or -, as in

* item 1
* item 2
* item 3

to achieve

• item 1
• item 2
• item 3

A numbered list can be achieved by starting the line with a number followed by a point. The numbering will start from the first number and the subsequent will be set automatically, such you don’t have to worry with the exact numbers written.

1. item 1
1. item 2
42. item 3

gives

1. item 1
2. item 2
3. item 3

An horizontal rule can be obtained by starting a line with --- or more dashes, achieving

---

To add comments that will not appear in the output, use <!--- hidden --->. The comments may also span several lines, as in

<!---
this entire block will not be shown in the output

so anything can be written here
--->

A code section (or verbatim, unformatted and monospaced text) can be set inside some paragraph using the syntax above, but for longer sections it is possible to use the notation below

```
This is a section of text
which is useful to put some code
```

which results in

This is a section of text
which is useful to put some code

Finally, while mathematical expressions can be placed inside the paragraph by placing the mathematical expression between single dollar signs, as in $x=2$ to obtain . However, to highlight some expression it is possible to write the expression between $$x=2$$ to separate it from the paragraph and make it centered, as in The next subsection explains how to write some sophisticate mathematical expressions.

Writing mathematical expressions

is a very robust language used to produce documents, being actively developed since 1984. Throughout the years lots of add-ons there were developed to handle difficult aspects of document formatting, as advanced typography and taking care of references. is particularly powerful to typeset math expressions and has lots of features, and it’s notation became an important standard to write math using computers. Jupyter notebook does not carry the whole power of , since it is constrained to the features provided by MathJax. However, several general features are available and this subsection will start with an overview of mathematical symbols. For instance, the table below shows how to write greek letters.

Symbol	Latex	Symbol	Latex	Symbol	Latex
	\alpha		\iota		\rho, \varrho
	\beta		\kappa, \varkappa		\sigma, \Sigma, \varsigma
	\gamma, \Gamma		\lambda, \Lambda		\tau
	\delta, \Delta		\mu		\upsilon, \Upsilon
	\epsilon, \varepsilon		\nu		\phi, \Phi, \varphi
	\zeta		\xi, \Xi		\chi
	\eta				\psi, \Psi
	\theta, \Theta		\pi, \Pi, \varpi		\omega, \Omega

Notice that omicron is the only greek letter that is not explicitly supported since it is indistinguishable from the latin letter o. Regarding notation, superscripts and subscripts are written respectively as ^ and _, such $2^3$ and $a_n$ become and , respectively. Quite often the latex expressions must have long sub- or super-scripts, such it is necessary to indicate with curly braces {} where the sub-(super-)script starts and ends. The next table also shows some common symbols and expressions in .

Expr	Latex	Expr	Latex	Expr	Latex	Expr	Latex
	^\circ C		\dot{x} \ddot{x}		\approx		\ell
	e^{-x}		\int_a^b		\equiv		\Re \Im
	\Gamma_i^j		\sum_{i}^{N}		\propto		\partial \nabla
	\frac{a}{x}		\cdot\,\times		\neq		\square
	\vec{E}		\gg \geq		\pm \mp		\infty

More comprehensive lists of symbols and operators can be found in the internet, as in Wikipedia for example. The following table contains the instructions for several standard functions and a few more symbols.

Expr	Latex	Expr	Latex	Expr	Latex	Expr	Latex
	\sin		\exp		\det		\sqrt[n]{a}
	\cos		\log		\lim		\prod_i^N
	\tan		\ln		\min		\oint
	\sinh		\sec		\max		\iint
	\cosh		\csc		\arg		\iiint
	\tanh		\cot		\sqrt{x}		\iiiint

In Portuguese the sine function should be written as sen, and this is not included by default. So, it is possible to express it in notation using \operatorname{sen} x, which results in . To finish this long list of available symbols, it’s useful to mention that has symbols which correspond to arrows and for brackets to group mathematical expressions. There are also instructions to control the spacing between symbols.

Expr	Latex	Expr	Latex	Expr	Latex	Expr	Latex
	\leftarrow		\uparrow		()		a \! a
	\Leftarrow		\Uparrow		[]		a a
	\rightarrow		\downarrow		\{\}		a \, a
	\Rightarrow		\Downarrow		\vert		a \: a
	\leftrightarrow		\updownarrow		\Vert		a \; a
	\Leftrightarrow		\Updownarrow		\langle \rangle		a \quad a

Notice that the curly brackets must be preceded by \, since otherwise they would be confused with the arguments of functions. Normally the brackets have a fixed size, but it is possible to allow them to change their sizes depending on what they enclose. For example, the parenthesis in $(\frac{\int a}{b})$ will not match the height of what it encloses (try it). However, adding the instructions \left and \right to indicate what’s between the parenthesis it can adjust its size. This correction implies in writing \left(\frac{\int a}{b}\right) (see how the behavior changes). Finally, notice that the last column in the above table contains commands to change the spacing between symbols, ranging from a negative distance \! to quad spacing. There’s also \qquad which is even larger than \quad.

After showing so many possibilities, it is useful to show some examples on how to compose these symbols to write mathematical expressions. Below there are several examples where you can see how to express in a given formula.

A = \left(15.02 \pm 0.02\right) 10^{-2}\text{ m} \hbar = \frac{h}{2\pi} = 1.054 \cdot 10^{-34}\text{ J/s} y(x) = \int_0^1 t\, dt = \left.\frac{t^2}{2}\right|_{t=0}^1 \sinh x= \frac{e^x - e^{-x}}{2} e^x = \sum_{i=0}^\infty \frac{x^i}{i!} = \lim_{n \rightarrow \infty} \left( 1 + \frac{x}{n} \right)^n f(a) = \frac{1}{2\pi i} \oint \frac{f(z)}{z-a} dz \vec\nabla\times\vec{H} = \mu_0\epsilon_0\frac{\partial\vec{E}}{\partial t} \ddot{x} + \gamma \dot{x} + \omega^2 x = 0 w(z) = w_0 \sqrt{1 + \left(\frac{z}{z_R}\right)^2}

Notice that the equations between pairs of $$ above are centered and separated from the text paragraph. For long documents it’s important to number and reference equations. Jupyter can handle this automatically, even though there are some rough edges when editting the notebook. Create and execute a code cell (preferably right when the document begins) containing only the instructions below to instruct MathJax to number ams equation environments. Another option is to use all instead of ams, such that equations between pairs of $$ will also be numbered.

%%javascript
MathJax.Hub.Config({
    TeX: { equationNumbers: { autoNumber: "ams" } }
});

The ams equation environments support more advanced modes to display equations. In summary, each environment is declared as \begin{env} your equation \end{env}, where env must be replaced by the environment of interest. Below there are some examples of some environments. Use the examples below within markdown cells.

\begin{equation}
y(x) = a x^2 + b x + c. \label{eq:quadratic_formula}
\end{equation}

\begin{multline}
y(x) = a x^2 \\
+ b x \\
+ c.
\end{multline}

\begin{align}
y &= 2 + 3, \nonumber \\
  &= 5. \label{eq:sum_result}
\end{align}

\begin{align}
a &= 1, & b &= 2,\\
c &= 3, & d &= 4.
\end{align}

You may notice that the equation numbering in edit mode is always referred to the equations contained in a single cell. If you put several equations in a single markdown cell they will be numbered sequentially, but the moment you start another cell the counting resets. This is a bug which is not verified when you export the notebook as a pdf or as an HTML file. Equations may contain labels as \label{eq:sum_result} at the end of a line which help to automatically refer to these equations in the text. For instance, the quadratic formula is , which can be referred to using $\eqref{eq:quadratic_formula}$. The result of is shown in Eq. and can be dynamically referred in the text using $\eqref{eq:sum_result}$. This is very powerful, since it’s not necessary to keep track of these numbers when changing the document. Quite often there are some equations that we don’t want to number. The environments above lose their numbering by adding an asterisk after the environment name, as in \begin{env*} your equation \end{env*}. We can also remove the numbering of specific equations using \nonumber.

Each equation environment above is more adequate for specific types of equations. equation is adequate for single mathematical expressions that may fit a single line. Sometimes there are single expressions that are too long, such they can be split along several lines using multline for better visualization. Two bars \\ are used to indicate where the line must break. The align environment is useful to exhibit several equations together. The expressions are aligned by & symbols and the lines end at \\.

The syntax to write down matrices and vectors is similar to that used in align. Columns are divided by & and the lines end at \\. The matrix is defined within it’s own environment inside an equation environment. See the example below.

\begin{equation}
  M =
  \begin{bmatrix}
  a & b \\
  c & d
  \end{bmatrix}
\end{equation}

There are several variations of the matrix environment, which are associated with the symbols used to enclose the matrix elements. The table below shows some examples.

Matrix type	Result
matrix
pmatrix
bmatrix
Bmatrix

The matrix is useful to express conditional equations, as

\begin{equation}
\Theta(x) =
\left\{
  \begin{matrix}
  0\text{, if } x<0 \\
  1\text{, if } x>0
  \end{matrix}
\right.
\end{equation}

It can also be used to express vectors, as in

\begin{equation}
    \begin{pmatrix}
    a_1 \\
    a_2 \\
    \vdots \\
    a_n
    \end{pmatrix}
    =
    \begin{pmatrix}
    c_{11} & c_{12} & \dots & c_{1n} \\
    c_{21} & c_{22} & \dots & c_{1n} \\
    \vdots & \ddots &       & \vdots \\
    c_{n1} & c_{n2} & \dots & c_{nn} \\
    \end{pmatrix}
    \begin{pmatrix}
    b_1 \\
    b_2 \\
    \vdots \\
    b_n
    \end{pmatrix}    
\end{equation}

Citations and internal references

Jupyter notebook currently does not natively support references to sections and figures, such that it is not practical to write complex documents in it without extensions. Below there are some suggestions on what can be done.

• For simple documents, the citations and references can be handled manually
• The cite2c extension allows to use Zotero references to perform literature citations. This is a solution for documents that does not require complex internal references to figures, tables and etc.
• The notebook can be used to compose the skeleton of the final document and later be exported to a .tex file. This export procedure will handle figure exports and mathematical expressions. Therefore, the document still must go through a final stage using a distribution such as MiKTeX.
• Pandoc is a document converter that support several formats, it’s native syntax being a markdown flavor. It is possible to use the notebook in a Pandoc based workflow. For example, it’s possible to use python to automate the conversion, or export the notebook to later perform the final adjustments directly using Pandoc.

As a final remark, the Jupyter notebook has an internal tool called nbconvert which is used to convert the notebook file to several formats. nbconvert supports templating, such once you can tune the conversion process to make your workflow easier.

Radial dependence

Suppose we want to find . How do we do this, given that we know ? We can build a map that indicates the coordinate of each pixel in the coordinate system of interest, as performed above for x,y,r,phi. We can use histograms to verify how frequent each value of r,phi appears in the image. Below we have the histogram of r in an array whose size is the same as profile. Notice that the growth is linear with r until the corners of the array are reached at . Resembles, at least slightly, the Jacobian of the coordinate transformation. Suppose now that the histogram of is weighted by the intensity profile, could this be equivalent to the coordinate transformation?

h = histogram(r, bins=nbins, weights=absolute(profile)**2)
hx = h[1][:-1]
hy = h[0]

h2 = histogram(r, bins=nbins)

subplot(211)
title('num of array elems with given r values')
plot(hx, h2[0], 'k.')

# Notice that the frequency of r[i] is proportional to r. Jacobian?
# It is necessary to normalize by h2!

subplot(212)
title('intensity vs radius?')
plot(hx, hy, 'k.')

tight_layout()

savefig(r"assets\xy_rphi_radial_histogram.png")

It’s very close indeed, however it is necessary to normalize by the number of pixels whose radius is r. Below this correction is performed and the theory and numerical conversion are compared. Notice the perfect matching, which indicates the present procedure is adequate.

title('avg intensity vs radius')

h1 = histogram(r, bins=nbins, weights=absolute(profile)**2)
h2 = histogram(r, bins=nbins)

hx = h1[1][:-1]
hy = h1[0]/h2[0]

factor = 1 if m==0 else 2

plot(hx, hy, 'k.', label='histogram transformation')
plot(hx, hx**(2*m) * exp(-2*hx**2)/factor, label='theory')
legend(loc=0)
savefig(r"assets\xy_rphi_radial_histogram_2.png")

Angular dependence

To obtain the angular dependence is similar, however some extra care must be taken. Consider the histogram of phi, weighted by 1 or the intensity profiles. Notice that while the radial distortion is due to pixels close to the image borders, in the azimuthal direction there are more pixels along certain directions (diagonals). This is important to notice because the contribution due to some angles can be disproportionate. Also, close to , some angles may be unavailable due to pixelation.

h = histogram(phi, bins=nbins, weights=absolute(profile)**2)
hx = h[1][:-1]*180/pi
hy = h[0]

h2 = histogram(phi, bins=nbins)

subplot(211)
plot(hx, h2[0], 'k.')
# Notice the distortion at the most frequent phi values
# The most frequent phi values are at the diagonals

subplot(212)
title('intensity vs angle?')
plot(hx, hy, 'k.')

tight_layout()
savefig(r"assets\xy_rphi_angular_histogram.png")

If the histogram is normalized as before, there will be some distortion due to the diagonals. To avoid this, we filter the image radially and obtain the following result is obtained. Notice how the numerical transformation nicely matches the theoretically expected result.

title('intensity vs angle at given radius')

rad = sqrt(1+m)/2
width = 0.3 # If this is too large, some distortion appear due to the frame edges and pixelation
mask = 1.0 * (r> rad-width/2) * (r < rad+width/2)

h1 = histogram(phi, bins=nbins, weights=absolute(profile)**2 * mask)
h2 = histogram(phi, bins=nbins, weights=mask)
hx = h1[1][:-1]*180/pi
hy = h1[0]/h2[0]

plot(hx, hy, 'k.', label='Numerical transformation')

ampl = rad**(2*m) * exp(-2*rad**2)
plot(hx, ampl*cos(m * (pi*hx/180 + offset))**2, label='Theory')

legend(loc=0)
savefig(r"assets\xy_rphi_angular_histogram_2.png")

Radial and angular dependence

Since the above considerations allowed to obtain the intensity vs radius or intensity vs angle, would it be possible to obtain intensity as a function of radius and angle? We can use 2d histograms to obtain this transformation, analogously to the previous cases. Some distinctions are important here. histogram2d() does not accept r, phi and profile as 2d arrays, such ravel() is used to convert these matrices to 1D ndarrays. Also, close to r=0 there will be several angles which cannot be found, such the normalization will be undefined. In such cases it could be possible to interpolate the data between well defined values. Notice that this is not a limitation of the present procedure, but an unavoidable issue in such transformation. Some pairs of r, phi do not exist, and therefore the method cannot infer these values automatically. Numpy assigns nan to these values and imshow exhibits these pixels in white. It is also important to notice that here it is important to limit the extent of values, otherwise the corners will be included and artifacts introduced in the representation.

title(r'$I(r,\theta)$')
data_range = [[0,5], [-pi,pi]]
h1 = histogram2d(r.ravel(), phi.ravel(), bins=nbins, range=data_range, weights=(absolute(profile)**2).ravel())
h2 = histogram2d(r.ravel(), phi.ravel(), bins=nbins, range=data_range)

im = imshow(h1[0]/h2[0], origin='lower')
colorbar(im)

xlabel("$\\theta$")
ylabel("r")

# The present approach has errors close to r=0, since there will not be pixels with some values of theta
# Interpolation is necessary to fill out the gaps where h2[0]==0 close to r=0.
# The number of gaps reduces with the number of bins

savefig(r"assets\xy_rphi_transform.png")

We can also put the theoretically expected profile and the result of the numerical transformation side by side to see that the transformation is meaningful. Both patterns are very similar.

subplot(121)
title('Theoretical')
im = imshow(absolute(profile_r_phi)**2, origin='lower', cmap=im.cmap)
xlabel("$\\phi$")
ylabel("r")

subplot(122)
title('Transf. result')

imshow(h1[0]/h2[0], origin='lower', cmap=im.cmap)
xlabel("$\\phi$")
ylabel("r")

savefig(r"assets\xy_rphi_side_by_side.png")

The difference between both patterns above is also very small, as it can be seen from the image below.

title('Difference (Th-Tr)')
delta = absolute(absolute(profile_r_phi)**2 - h1[0]/h2[0])
im = imshow(delta, origin='lower')
colorbar(im)
xlabel("$\\phi$")
ylabel("r");
savefig(r"assets\xy_rphi_difference.png")

Arduino e suas bibliotecas

Antes de mais nada, é fundamental que a IDE do arduino esteja instalada. Acesse http://www.arduino.cc e faça o download e a instalação do programa, seguindo as instruções recomendadas para o seu sistema operacional.

Nota para usuários de sistemas linux. A instalação da IDE arduino por vezes não permite a comunicação com a placa diretamente. É necessário acessar o terminal e digitar sudo usermod -a -G dialout <username>, onde <username> deverá ser substituído pelo nome da conta de usuário que terá autorização para programar e se comunicar com o arduino. Após a autorização é necessário reiniciar o sistema.

Faça o teste básico do led piscando Arquivo>Exemplos>01. Basics>Blink para verificar se tudo está funcionando corretamente. O próximo passo é instalar as bibliotecas que precisaremos para controlar alguns sensores e periféricos. Na IDE arduino, acesse o menu Sketch>Incluir bibliotecas>Gerenciar bibliotecas. Busque e instale as bibliotecas abaixo:

• Wire
• Adafruit Unified Sensor Library
• DHT sensor library
• LiquidCrystal I2C
• IRremote
• RF24

A brief recapitulation of amplifiers nomenclature

An amplifier is a device that receives some signal (current or voltage) at its input and outputs another signal (also a current or voltage). There are then 4 possible configurations. Suppose that at the input one has a voltage signal , and the output is another voltage . This amplifier can be characterized by its voltage gain . For an amplifier which inputs and outputs currents, we also can characterize the current gain as . Notice that and are unitless quantities. Now, if an amplifier accepts a current as an input and outputs a voltage, we can’t characterize any gain in terms of an unitless quantity. To remain the gain characterization in terms of signal out/signal in, we must have , which has units of Ohms. For a constant, DC signal, would be a resistance, while in general for time varying signals is called an impedance. Equivalently, if an amplifier has an input voltage and outputs a current, it’s called a transconductance amplifier, due to its gain (expressed in Siemens, or )

Design of a transimpedance amplifier

%pylab inline

# Represent the ideal photodiode response
wavelengths = linspace(350, 1150, 100) # UV to near IR
bandgap = 1100 # Silicon bandgap at room temperature
responsivity = wavelengths/1240 # Ideal case responsivity
responsivity[wavelengths>bandgap] = zeros(wavelengths.shape)[wavelengths>bandgap]

# Consider the data for Thorlabs's FDS100 and BPW34 as a comparison
fds100 = loadtxt(r'assets\TIA_FDS100_Responsivity_data.csv', skiprows=1, unpack=True)

# Data retrieved directly from the datasheet using the getdata graph digitizer
bpw34 = loadtxt(r'assets\TIA_bpw34_spectral_response.csv', unpack=True)
i = absolute(bpw34[0]-950).argmin() # Which index corresponds to 950 nm?
bpw34[1] = bpw34[1] * 0.66 / bpw34[1,i] # Adjust the normalized response by the responsivity

plot(wavelengths,responsivity, label="Ideal case")
plot(fds100[0], fds100[1], label="FDS100")
plot(bpw34[0], bpw34[1], label="BPW34")

grid()
xlabel(r"Wavelength (nm)")
ylabel(r"Responsivity (A/W)")
title(r"Responsitivity vs Wavelength")
legend()
savefig(r'assets\TIA_ideal_responsivity.png')

# Conversion of BPW34 datasheet parameters to responsivity @ 950 nm
I_revCurrent = 50e-6 # A
irradiance = 1 * 1e-3/(1e-2)**2 # W/m^2
area = 7.5 * (1e-3)**2 # m^2
R = I_revCurrent / (irradiance * area)

%pylab inline
V_D = linspace(0, 100, 100) # Voltage across diode, in mV

R = 1e6     # 1MOhm resistor
I_D = 2e-9  # Dark current (in A)
V_T = 25    # Carrier thermal energy at room temperature (in mV)

v_rev_0nA = V_D
# the 1e3 factor below converts the voltage to mV
v_rev_2nA = V_D + (R * I_D * 1e3) * (exp(V_D/V_T)-1)

# Approximate a mean linear relation between V_D and v_rev
i = abs(V_D-60).argmin() # Which V_D index is closer to V_D==60 mV?
V_mean_slope = (v_rev_2nA[i]-v_rev_2nA[0])/(V_D[i]-V_D[0])
v_linearized = V_mean_slope * V_D

plot(v_rev_0nA, V_D, label=r'$I_D=0$')
plot(v_rev_2nA, V_D, label=r'$I_D=2$ nA')
plot(v_linearized, V_D, label=r'Linearized relation')
legend()
ylabel(r'$V_D$ (mV)')
xlabel(r'$V_{rev}=V_D + R I_D \left(e^{V_D/V_T}-1\right)$ (mV)')
grid()
savefig(r'assets\TIA_diode_saturation.png')

C = 70e-12
R_F = 1e5
GBP = 2 * pi * 1e6
4 * GBP * R_F * C # 175.92918860102841

C = 100e-12
GBP = 2*pi* 1.0e6

R_F = logspace(4,7,100)
our_eq   = (1+sqrt(   4 * GBP * R_F * C))/  (GBP * R_F)
maxim_eq = (1+sqrt(1+ 8 * GBP * R_F * C))/(2*GBP * R_F)
ti_eq    = (1+sqrt(1+ 4 * GBP * R_F * C))/(2*GBP * R_F)

semilogx(R_F,   our_eq*1e12, label='This')
semilogx(R_F, maxim_eq*1e12, label='Maxim AN 5129')
semilogx(R_F,    ti_eq*1e12, label='TI RD 176')
grid(); legend(); xlabel('$R_F$ ($\Omega$)'); ylabel('$C_F$ (pF)')
title(r'Feedback capacitor selection - $C=100$ pF, $f_{GBP}=1$ MHz')
savefig(r'assets\TIA_feedback_capacitor_selection.png')

C = 70e-12
R_F = 1e5
GBP = 2*pi* 1.0e6

C_F = (1+2*sqrt(GBP * R_F * C))/(GBP * R_F) # 23 pF
C_F

Some opamp specs

Below are shown some specs for some ordinary opamps.

	LM324	TL074	LF411	TLC2264	TLC2274
Input type	BJT	FET	FET	CMOS	CMOS
	1 MHz	3 MHz	4 MHz	0.71 MHz	2.2 MHz
	45 nA	65 pA	50 pA	1 pA	1 pA
	2 mV	3 mV	0.8 mV	0.3 mV	0.3 mV
P. Supply	Single	Dual	Dual	Single	Single

Simulation

Experimental results

Complete python code

Basic setup

jupyter notebook

A quick start to Python programming

By default, the new notebook is opened with an input field (a Cell) adequate for code input (for other input types see the dropdown menu currently stating Code). Type print("Obey the gravity. It's the law!") in the cell and press Shift + Enter in your keyboard. The output must be

Obey the gravity. It's the law!

This is a small program which indicates that you want that the program returns a text (more correctly string) informing a given comment. Python understands anything between single 'text' and double "text" quotes as a text. In Jupyter notebook the output of a given cell is just below the associated input code.

Now you think… well… the above code is nice. But, I want to perform experiments, and what I need is a computer to do heavy and difficult calculations. Python allows you to also do that easily. Consider a sum of two terms:

2+2

Press Shift + Enter to execute the above code and check that the answer is correct. You can also try to improve the output. It’s possible to send several arguments to any function by separating expressions with a comma. to make your statement stronger:

print("The sum of 2+2 is", 2+2)

Python is very good at math. Indeed, we can perform several mathematical operations. Sum +, Difference -, Multiplication * and division / operators are available. Powers can be calculated with ** (Ex.: is written as 2**3), and operations can be grouped with parenthesis (1/(1+1) == 0.5, while (1/1) + 1 == 2). Python calculates powers, multiplications and divisions before sums and differences (See operator precedence). Thus, when in doubt it’s a good practice to separate multiplication and division terms with parenthesis. We can also use variables to store information (numbers, texts and even more complex structures lying ahead). Suppose that we want to consider the parabolic trajectory of a mass due to the action of gravity. We may define the variables y0, v0 and a to store the initial information of the mass launch (initial height, initial velocity and acceleration) as follows:

y0 =  0.0 # m
v0 = 20.0 # m/s
a  = -9.8 # m/s**2

Whenever we refer later to y0, v0 or a we can retrieve these values from the computer memory. In this way we can, for example, write down mathematical formulas involving y0, v0 and a and let the computer remember which number is associated with each quantity. This is interesting because it allows us to do and redo a given set of calculations just by changing these initial values. We don’t have to rewrite each step of the calculation, since we will later describe in Python which calculations we want the computer to perform.

Notice that each instruction occupies one line. In the previous cell we had 3 instructions which only stored numbers in the memory. The units, as m/s, are not stored. Therefore, we must be careful with the units of each variable, or be sure that the adequate conversions are considered at the beginning or at a later stage. To keep track of the units it’s useful to add comments at the end of the line. Python will ignore everything after a # symbol, and you may add any text. Comments are useful to understand what the program is doing at each step. Also notice that the decimal separator in python is the period ., and not the comma ,. Commas are always¹ used to separate expressions, as function arguments.

Once all variables are available in the memory, you may calculate the mass height at a given time using the known formula . For example, at , if we now request the python program to calculate

y0 + v0 * 3 + a * 3**2 / 2 # Calculate the mass height at t=3 s

15.899999999999999

To obtain the particle height at other times, we may replace the time by another time of interest. Also, we may the motion parameters y0, v0, a by updating the variable values. For example, if the particle now has an initial velocity of 15 m/s, we may adjust the initial velocity with the following code:

v0 = 15 # m/s

An important remark is that the variable names must be typed exactly in the same way everywhere. v0 and V0 are different variables. The syntax (or how do you exactly write things) is extremely important in a computer language. The computer is “dumb” and will only follow exact instructions. Any language imprecision will give errors.

Python variables can store other types of information, besides numbers. For example, they may be used to store text (strings):

message = "The current initial velocity is"

print(message, v0)

Functions

It would be extremely annoying if we had to enter the time everywhere it appears in the trajectory formula whenever we want to determine the mass position. One approach to let the program calculate for us by defining the function as a python function. There are two basic ways to define a function in python. Through the so called lambda functions, one has

y = lambda t: y0 + v0 * t + a * t**2 / 2

the general structure of a lambda function is 'function name' = lambda 'arguments': 'python expression'. To calculate the function value we can simply type y(3), y(1.5), … Test the output values in a new cell for several values of t. Notice that the function contains y0, v0 and a which are variables stored in memory. Try to change the values of these variables and see how they affect y(t). While here we are considering a function of a single argument (), it’s possible to have multiple arguments too. For example, suppose that we want to consider the height at a time for a particle that starts at and allow the initial velocity to change. We may define a more specific function to this problem

y2 = lambda t, v0y: v0y * t - 9.8 * t**2 / 2

Thus, if we want to consider this second scenario, we may use python to call y2(1, 10) to know the particle height at t=1 s and with an initial velocity of 10 m/s. Notice the ordering: the first number indicates the value of t, while the second number indicates the value of v0y. Another possibility is to use a variable to set the argument values, as in y2(2, v0). We may also use y2(3.5, 13.2) to consider the particle height at 3.5 s given an initial velocity of 13.2 m/s. Notice also that the comma is an argument separator (separates the arguments t and v0y), while the period is a decimal separator in python. Thus, if one tries to type a number with the comma as a decimal separator it will lead to an unexpected behavior (may even trigger error messages). For example, y2(3,5, 13,2) will send four arguments (3, 5, 13 and 2) to y2, while y2 accepts only two arguments (t and v0y). Calling y2(3,5, 13,2) will lead to an error message.

Sometimes the function definition through lambda functions as above is not very adequate, because Python functions are more general than mathematical functions and can also be used to request the computer to perform a more complex set of tasks. For instance, suppose that we want to know simultaneously both the particle height and velocity with a single function. We may define a function as

def parabolic_motion(t, v0y):
  yt = v0y * t - 9.8 * t**2 / 2
  vt = v0y - 9.8 * t
  print('at t=', t, ', y(t)=', yt,', v(t)=', vt)
  return yt, vt
# Function ends where indentation ends

final_height, final_velocity = parabolic_motion(5, 15)

Test the above code. After the line def ... there are several instructions, which must be indented (that is, each line starts with two spaces or more, or a TAB key press). The same indentation that you use in the first line must be used in the following ones within the function. When the indentation stops it means that the instructions that should be performed by the function have ended. Given a time t and initial velocity v0y, it will compute the height and store it in yt, then it will compute the particle velocity and store it in vt. Then, it will print to the user a string informing the current time, height and velocity. print accepts several arguments, where some of them are strings (text between quotes) and the others are variables. Always remember that commas are used to separate expressions or arguments. Finally the return instruction will send the values of yt and vt as the function output. Thus, the above steps will be carried sequentially and the function will return two numbers that can be attributed to other variables. For instance, final_height, final_velocity = parabolic_motion(5, 15) will set final_height=-47.5 and final_velocity=-34. The general structure is

def 'function name'('arguments'):
  'indented instructions'
  ...
  return output
  # Function 'function name' ends here.
# The program instructions follow unindented below

Advanced math and arrays

The previous concepts can be used to define some simple mathematical functions, as polynomials. However, we often need a broader set of functions in our calculations. For instance, we may need trigonometric, hyperbolic, exponential or logarithmic functions. Also, we may need to use constants as or . There are basically two ways to introduce such functions in a python program. The first one is through the native math library. In programming, a library represents a set of functions (or objects) that solve some set of problems. To use a given library, we may use the import 'library' instruction. To call a given library function or constant, it’s possible to use a syntax like 'library'.'function', or 'library'.'constant'.

import math

print(math.sin(math.pi/2))

1.0

To consult the available constants, functions and other python objects, one may consult the math library documentation, or use some autocompletion features in the editor. For instance, if you type a period after math, math., and press the TAB key, then the interface will display a menu containing the available properties. For instance, math.si+tab shows math.sin and math.sinh as options. Since these are functions, we may add the parenthesis to begin the function call. To see how these functions operate, its possible to use Jupyter notebook’s tooltip feature. Consider math.sin( and type Shift+Tab. A documentation regarding the syntax and usage of that function will be readily available.

While the above possibility is very general and can be used to import other libraries, the Jupyter notebook can perform a magic that automatically simplifies enormously the syntax of complex mathematical expressions. One of the most convenient is the %pylab magic, which I recommend calling only once at the beginning cell of a notebook. Type in some cell

%pylab inline

the inline option is related with the tool that we will use later to plot curves. After the %pylab inline magic is called, we may calculate the sine more clearly:

print(sin(pi/2))

1.0

Python is also able to handle complex numbers natively. The imaginary number is 1j, and one can easily obtain results as the Euler’s identity: is verified within the calculation precision,

exp(1j * pi) + 1

1.2246467991473532e-16j

A remark on numeric notation in python. In a number, e indicates the exponentiation over a base 10. Thus 1e1==10, 1e2==100, -1.5e-2==-0.015. The smallest number that can be accurately calculated is called epsilon and can be obtained from sys.float_info.epsilon. My machine’s epsilon is 2.220446049250313e-16. Since this is the smallest increment/decrement that can be calculated, some calculations suffer from accuracy with such small numbers and the expressions should be normalized. Numerical calculations may also involve infinity (for example, log(0)==-float('inf')) while another important symbol is not a number, NaN, which is returned for undefined operations as , or float('inf') - float('inf') == float('nan').

When using complex numbers, there are several auxiliary functions available. For example, if we have c = sqrt(3)/2 + 1j * 1/2, we may compute the real and imaginary parts of c simply from real(c) and imag(c). The absolute value of c is abs(c), while the angle (in radians) between c and the real axis in the complex plane is angle(c). This angle is limited to the domain .

The %pylab magic does not use the standard python math library. Instead, it uses the Numpy library, which has much more capabilities. Numpy contains a large set of tools to handle numerical data, from matrix operations to fast Fourier transforms. It’ worthwhile to comment that python is a great language to code with, because it’s fast to create and test pieces of code. However, this increased facility comes at a cost in processing time when python code is used directly. Numpy implements several important numerical procedures using other languages² that process data much faster than native python. When crunching numbers, use Numpy/Scipy methods as much as possible. Scipy is another library which contains several applications of Numpy to a multitude of science-related problems.

Quite often one has to deal with functions defined within a certain range of variable values, a finite domain. The Numpy library has two main auxiliary functions that allow us to define this domain for mathematical functions, arange and linspace. arange([start], stop, [step]) indicates an array of integer numbers starting from start (which is an optional argument, 0 by default) to stop, in equally separated step steps (optional, step=1 if not given). Notice that arange does not include the stop as a value in the array. This is sometimes useful, but must always be remembered. In the code below, x starts at 2 and increases in steps of 2, until the array value is lesser than the stop=9 value. This will produce an array containing the even numbers from 2 to 8. y contains the positive integers (including 0) lesser than stop (remember that the default step is 1). It’s also possible to produce an array of fractional values with a given spacing, as in z.

x = arange(2, 9, 2)
y = arange(10)
z = arange(1, step=0.1)
x, y, z

(array([2, 4, 6, 8]),
 array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
 array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9]))

While arange does not include the final point and one must define the spacing between values, linspace(start, stop, num) takes another approach. It will create an array of values between start and stop. The endpoint is included by default. num indicates how many points the array must have between start and stop, and is quite useful to increase or decrease the resolution in which a given function is represented in a given domain. The definition os a given step as in arange can be less intuitive when we want to represent functions in different domains. linspace is more adequate for fractional spacing than arange.

x = linspace(0, 1, 10)
y = linspace(0, 10, 3)
z = linspace(0, 10, 5)
x, y, z

(array([ 0.        ,  0.11111111,  0.22222222,  0.33333333,  0.44444444,
         0.55555556,  0.66666667,  0.77777778,  0.88888889,  1.        ]),
 array([  0.,   5.,  10.]),
 array([  0. ,   2.5,   5. ,   7.5,  10. ]))

Notice that now x contains an array of 10 values and includes the endpoints. Considering that the number of intervals is num-1, the spacing between subsequent points is (stop-start)/(num-1). Notice num represents the number of point in the array, and to obtain intervals with a given sort of regular spacing, as w=(stop-start)/divisor, one must use num = divisor + 1.

The output of arange and linspace are array objects, which is the basic way that Numpy uses to handle sets of numbers. If we want to define arrays over a given set of values, we may also use the following syntax

a = array([1,2,3,5,7,11,13])
b = array([0.1, 0.3, 0, -52, 42])
c = array([ 1, 1+2j, -3, -1-1j])
a, b, c

(array([ 1,  2,  3,  5,  7, 11, 13]),
 array([  0.1,   0.3,   0. , -52. ,  42. ]),
 array([ 1.+0.j,  1.+2.j, -3.+0.j, -1.-1.j]))

The set of numbers separated by commas within square brackets [1, 2, ...,] is a Python list, which is a python object that can be used to store ordered information. Beware that the order in which the data is added is retained. Also, notice that if one adds complex numbers the array automatically considers that all numbers in the array are complex. Each element in the list is associated with an index used to locate such element. To access the elements of the list x = ['a', 'b', 42, [-5, 1j] ] we can use x[i], where i ranges from 0 to 3. In particular, x[0]=='a', x[1]=='b', x[2]==42 and x[3]==[-5, 1j].

A great aspect of arrays is that one may easily perform calculations over them. For instance, we may create an array with even numbers from 0 to 10 using an arange. arange(6) creates the array [0, 1, 2, 3, 4, 5], while the multiplication by 2 multiply each value individually.

2*arange(6)

All of the basic operations (+, -, *, /, **) and the Numpy functions can be calculated over each value in the array. Thus, consider that we want to calculate the values of a linear function, . The Numpy array is such that if we have an array x and we call y = 2 + 15 * x - 5 * x**2, then y will be another array that contains the result of the calculation of the right-hand side expression for each value of x. Numpy will get each value of x in the array, evaluate the mathematical expression, and return the output value to y at the corresponding x value position. An important aspect is that Numpy evaluates the native mathematical functions and expressions quite efficiently, and since the python expression can look like the mathematical function that we want to calculate, it’s easy to check for errors.

x = linspace(0, 5, 11)
y = 2 + 15 * x - 5 * x**2
x, y

(array([ 0. ,  0.5,  1. ,  1.5,  2. ,  2.5,  3. ,  3.5,  4. ,  4.5,  5. ]),
 array([  2.  ,   8.25,  12.  ,  13.25,  12.  ,   8.25,   2.  ,  -6.75,
        -18.  , -31.75, -48.  ]))

The above code represents the set of (x, y) values that satisfy the relationship expected for the function . However, it would be much nicer if we could see this in a graphical representation, as we’ll see just below. To finish this section, we may notice that we may use functions to calculate these results.

x = linspace(0, 5, 11)
y = lambda t: 2 + 15 * t - 5 * t**2
x, y(x)

(array([ 0. ,  0.5,  1. ,  1.5,  2. ,  2.5,  3. ,  3.5,  4. ,  4.5,  5. ]),
 array([  2.  ,   8.25,  12.  ,  13.25,  12.  ,   8.25,   2.  ,  -6.75,
        -18.  , -31.75, -48.  ]))

Notice that y is a lambda function that has a generic argument t, instead of x directly. An advantage of the function definition above is that now it is possible to evaluate the function y(t) over distinct Numpy arrays, and we don’t have to rewrite everything. For example, suppose that somewhere else we want to evaluate y over a larger domain z and at a higher resolution. We may use simply

z=linspace(-10,10,100)
z, y(z)

Basic curve plotting

Obtaining a list of calculated values is very important, since the computer can calculate very fast and efficiently. However, it’s often easier to understand data if we can visualize it in a graphic. The matplotlib package contains several tools to produce high-quality data plots (both in 2D and 3D). Another interesting aspect is that matplotlib contains several examples which are useful under several data plotting contexts. For us, we will see some of the most basic capabilities.

In the previous section, we calculated for . This function can be graphically represented with the simple command plot(x, y)

x = linspace(0, 5, 11)
y = 2 + 15 * x - 5 * x**2
plot(x, y)
savefig(r'assets\pes_parabola_plot1.png')

The function savefig(r'assets\pes_parabola_plot1.png') saves the current matplotlib graphic in the external file pes_parabola_plot1.png located in the folder assets. The folder must exist before the file is written! Several output graphics file formats are supported, and this is useful to include the analyzed data in other documents (for example in Word, LaTeX,…). Notice that the above plot has some sharp corners, which are due to the small number of points used to represent . We can improve the graphic resolution by changing the number of points in the x array:

x = linspace(0, 5, 101)
y = 2 + 15 * x - 5 * x**2
plot(x, y)
savefig(r'assets\pes_parabola_plot2.png')

A typical scientific plot has several features, as a title, axis labels and maybe a legend, to indicate what is represented in each curve. In the example below we can see how to show several curves and add some of these features

# Parabola representation with a low resolution
x = linspace(0, 5, 5)
y = 2 + 15 * x - 5 * x**2
plot(x, y, '--', label="low res.")
plot(x, y, '.', label="low res. points")

# Parabola representation with a high resolution
x = linspace(0, 5, 101)
y = 2 + 15 * x - 5 * x**2
plot(x, y, '-', label="high res.")

# Plot properties
title('$y(x)= 2 + 15 x - 5 x^2$')
xlabel('x (m)')
ylabel('y (m)')
legend() # Use legends
grid() # Use grid

savefig(r'assets\pes_parabola_plot3.png')

The plot function accepts several arguments, and its complete description is given in the documentation. The string after the x and y data is used to set the curve format properties (color, line type, markers…). In the above example we set the line type as dashed (--), dotted (.) or a solid line (-, the default). It is also possible to associate a symbol to each pair of x,y data coordinates, some common ones being o, *, +, x that respectively generate the symbols . The color changes automatically, but can also be selected in the format string. To identify each curve in the plot, we label each curve. These labels only appear when legend() is called. The location of legend can be set by using the argument loc= (See documentation). title, xlabel and ylabel are used to set the plot title and horizontal and vertical axis labels. A nice feature is that matplotlib accepts LaTeX typeset formulas in its labels (check the LaTeX wikibook).

x = linspace(0, 5, 101)
y = pi + 15 * x - 5 * x**2
plot(x, y)

title(r'$y(x)=\pi+\int_0^x \left(15 - \frac{20}{2} t\right) dt$')
xlabel('x (m)')
ylabel('y (m)')

savefig(r'assets\pes_parabola_plot4.png')

In the above plot the title contains terms as the integral operator \int and the greek letter \pi. LaTeX formulas must be within a string and enclosed by dollar signs $. Quite often these strings can be misinterpreted by python, given that \ is used in strings to describe some special characters. Thus, when typing latex formulas one must define raw strings by adding the character r immediately before quotes in the formula-containing string. Quite often we want to write sub or superscripts in our expressions, and the Latex notation is very simple. can be written as $x_1$, or a more general subscript must be enclosed between curly brackets, $\psi_{1,2,3}$. The superscripts are similar, typical examples being $e^{-x^2}$ or $2^{2^2}$.

To finish this section, we consider a few difficult function calculations. Notice that the same x array is used to represent all functions.

x = linspace(0, 10, 201)

y = 3 * sin(6*x) * exp(-x)
plot(x, y, label=r'$3 \sin(6x) e^{-x}$')

y = - 0.9 * sqrt(sin(x)**2 + cos(x)**2)
plot(x, y, ':', label=r'$- 0.9 \sqrt{\sin^2(x) + cos^2(x)}$')

y = abs(x - 5)
plot(x, y, '--', label=r'$|x-5|$')

y = log(2*x + 1)
plot(x, y, '-.', label=r'$\log\left(2x + 1\right)$')

title(r'Several mathematical functions')
legend()
xlabel('x')
ylabel('y')

savefig(r'assets\pes_plots_example.png')

Summary

In the present tutorial we have seen how to install Python and the Jupyter notebook, how to use Python to calculate simple expressions, a brief introduction to python variables and functions, Numpy mathematical tools and how to use matplotlib to plot Numpy arrays and numerical functions. In the following part we will see how to analyze experimental data in Jupyter notebook.

High-pass filter analysis

How much of a signal at a frequency passes through a high-pass filter whose cut-off frequency is ? The fraction of the signal that is allowed to pass through the filter is informed by the transfer function . For a first-order high-pass filter, where is the imaginary unit, .

We want the most of the a signal whose frequency is , while blocking most of the noise at . In other words, we’re interested in the amplitude of both signal and noise after the filter. The amplitude of a filtered signal at a frequency is given by

Now we know the fraction of the signal and noise which are allowed to pass through the filter. Let us consider which value of must be chosen. If is too small, then both signal and noise have a “high frequency” and are allowed to pass. On the other hand, if becomes too large, then both signal and noise have a “low frequency” and thus the filter removes the information of interest. There must be some optimal value for under some appropriate constraints.

In the plot below there are considered the relative amounts of signal at 1 kHz (blue) and noise at 100 Hz (orange) after the filter, as a function of the filter cutoff frequency . The high-pass filter is useful only between . For frequencies outside this range, the filter does not discriminate signal and noise from each other.

We want that the output does not affect the signal by much, while it attenuates the noise. To achieve this we may consider a figure-of-merit which is proportional to the signal transfer and inversely proportional to the noise transfer. More signal and less noise should increase this figure. A simple calculation shows that

is shown in the plot above as the green curve. Notice that if then the signal attenuation is relatively small, but the ratio is appreciable. Indeed this makes sense, given that to get rid of low frequency noise it’s necessary to have a filter with the highest available cutoff. Meanwhile, the highest cutoff which does not affect the signal by much is precisely when .

Figure-of-merit (Edit)

Another approach to characterize the effectiveness of the filter is through the definition of a figure of merit, that increases when the signal increases at the output, while it also increases for an enhanced ratio. This quantity would be . Below we show how the FOM depends on frequency for the above filter. The proposed FOM makes it clearer that the filter must be at the signal frequency.

Summary

The above analysis is simplified but valid under various circumstances. When selecting the cutoff frequency of a given filter one must first consider to put this frequency as close as possible from the signal frequency, but not larger. However, if the total noise signal becomes negligible at smaller values, then such values are preferred given that less signal will be lost. Also, a higher order filter can do a much better job at filtering than this simple RC filter. Finally, it is quite straightforward to achieve a similar conclusion for a low-pass RC filter to select a signal which has a frequency smaller than that of the relevant noise source.

Python code to produce the above plot:

%pylab inline

f = logspace(1,6,100)
fn = 100   # Noise freq.
fs = 1000  # Signal freq.
signal_transfer = fs/sqrt((fs**2+f**2))
noise_transfer  = fn/sqrt((fn**2+f**2))
sn_ratio = sqrt((fn**2+f**2)/(fs**2+f**2))
psig = semilogx(f, signal_transfer, label=r"$|T_{Signal}(f_c)|$")
pnoi = semilogx(f, noise_transfer , label=r"$|T_{Noise}(f_c)|$")
psnr = semilogx(f, sn_ratio       , label=r"(S/N ratio)$\cdot\frac{f_n}{f_s}$")
vlines(fs, 0, 1.0, color=vars(psig[0])['_color'], linestyle="dashed", label=r"$f_s=%d$ Hz"%fs)
vlines(fn, 0, 1.0, color=vars(pnoi[0])['_color'], linestyle="dashed", label=r"$f_n=%d$ Hz"%fn)
legend()
xlabel('$f_c$ (Hz)')
grid()
tight_layout()
savefig(r'assets\sn_ratio_hpf.svg')

%pylab inline

f = logspace(1,6,100)
fn = 100   # Noise freq.
fs = 1000  # Signal freq.
signal_transfer = fs/sqrt((fs**2+f**2))
noise_transfer  = fn/sqrt((fn**2+f**2))
sn_ratio = sqrt((fn**2+f**2)/(fs**2+f**2))
psig = semilogx(f, signal_transfer, label=r"$|T_{Signal}(f_c)|$")
pnoi = semilogx(f, noise_transfer , label=r"$|T_{Noise}(f_c)|$")
FOM = semilogx(f, sn_ratio * signal_transfer    , label=r"FOM")
vlines(fs, 0, 1.0, color=vars(psig[0])['_color'], linestyle="dashed", label=r"$f_s=%d$ Hz"%fs)
vlines(fn, 0, 1.0, color=vars(pnoi[0])['_color'], linestyle="dashed", label=r"$f_n=%d$ Hz"%fn)
legend()
xlabel('$f_c$ (Hz)')
grid()
tight_layout()
savefig(r'assets\sn_ratio_fom.svg')