2.1

ALOP workshops

Since 2004 many workshops were organized throughout the word within the framework of the UNESCO project ‘‘Active Learning in Optics and Photonics” (ALOP) with the support of ICTP (Abdus Salam International Centre for Theoretical Physics, Trieste, Italy) and generously supported over the years by SPIE (SPIE – The International Society for Optics and Photonics) Other support has come from as well the Optical Society of America, The National Academies (USA), The European Optical Society, Esssilor Corporation, etc.^9-15. This project promotes a hands-on method for teachers and students in optics using very simple and inexpensive material (homemade or locally available material when possible) and also avoiding as far as possible reference to mathematical/quantitative expressions. Furthermore, and in order to overcome the passive attitude of students during traditional lecture format, the teaching paradigm is Predictions, Observations, Discussions and Syntheses (PODS) in order to improve the conceptual understanding of optics. For instance, more than fifteen workshops have been organized just in Tunisia since 2005. Lessons focus on several topics usually found in any introductory university/or high school physics programs such as geometrical optics, interference and diffraction, atmospheric optics and optics in communications. Figure. 1 illustrates the context in which active learning procedure works.

Figure.1

: From left to right: Laser pointer fixed on a small patch of polystyrene in front of slits made by cutting the backside of a plane mirror - Group of students proposing solutions followed by a discussion - Experience highlighting a virtual image - Demonstration of the refraction of light by means of a laser and a vessel filled with liquid.

2.2

Organization of ALSO workshops

We propose here a new series of workshops (denoted as ALSO workshops) keeping the hands-on approach applied to the same contents e.g. optics but adding mathematical solutions and their numerical modeling. The idea here is to append to those experiments, such as those shown in Figure.1, codes that allow the manipulation of the experimental configurations that can help to generalize and better understand the concepts previously discussed. As for the experiments, we should give a special care to the training during the coding encouraging students to be active during the development of the codes applying the same PODS method. The main drawback here could possibly be the price of computers. These workshops should last almost the same time e.g. two or three days (the full ALOP workshops last for 5 days and cover 5 modules as well as a pre- and post- workshop conceptual evaluation test). We will choose only two or three modules per workshop and for each module we will manage half day for experiment and half day for the program development.

3.1

How to start programming

Starting to program is always something complicated. We never know exactly at which level we should start. Should we explain bit and addressing and occupying memory or should we start with syntax and instructions? Part of the answer to this question resides in what we want to do. As physics educators, in the context of the active learning and hands-on teaching, we suggest starting with subsections of programs carrying out specific tasks. Generally, an entire program can be divided into two parts: one dedicated to analytical solutions and the other for displaying curves and graphs. For example let’s focus on the diffraction-interference phenomena and more precisely on the Young double slit experiment. Here, the normalized intensity is expressed as:

‘b’ stand for the width of the slits, ‘a’ stand for the distance between slits, ‘D’ is the distance of the screen to the plan of the slits and ‘λ’ is the monochromatic wavelength of the incident light.

This example is very convenient for numerous reasons. It is very easy and inexpensive to realize experimentally and at the same time it highlights phenomena, such as interference and diffraction, which are not easy to understand and teach. The material shown on the left of Figure.1 is sufficient to do that. Slits are made manually on the plate in front of the laser simply using knife-edge. For the Young double slits we try to make two slits as parallel and identical as possible. So it fits well the hands-on approach we whish to promote. Similarly this hands-on approach could be applied on the numerical modeling. The program bellow simulates the Young double slit configuration and as highlighted it can be divided in two parts one dedicated to the mathematical solution and the other for the graphics.

You can copy this script, past it into python editor and run it as it is. This will generate Figure 2

Figure.2 :

Distribution of the normalized intensity observed on the screen. The dashed curve represents the sin(Bx)/(Bx).

The hands-on method appears through the ability to easily change the physical parameters (b, a, D, λ) and then determining the different patterns favoring predictions and discussions (OPDS). Of course it is not always easy to experimentally change the wavelength (λ) but thanks to the simulation we can vary it simply through the ‘lamda’ variable (see script) expanding the possibilities of OPDS. This point shows clearly the complementarity between experiments and programming.

Another interesting aspect here from the point of view of interactive learning in programming is the fact that we can focus on some basic and important notions we systematically encounter when modeling. This has to do with discretization. For instance, let us change in the script above the number of mesh point ‘N’ and give it the value N=30. The result is displayed in Figure.3.

Figure.3 :

Same physical configuration as in Figure.2 but with N=30 instead of N=400

As we can rapidly observe on this curve is that the number of peaks inside the central diffraction envelope goes from 5 to only 2 peaks. Actually, when we choose the number of mesh points for any discretization problem we have to deal with resolution problems and here resides many basic aspects in physics, raising many interesting questions.

The second part of the program is fully dedicated to the graphs and here also we can take time to learn how to better manipulate graphics libraries and determine the appropriate physical phenomena representation.

3.2

Interfacing the programs

Interfacing the programs is the next step that we shall realize after having manually tested the correctness of the script. This operation allows us to vary interactively the physical parameters without the need to return to the script. Practically, it involves associating widgets with curves into the graphics, which allow us to modify and extract the important information. Typical widgets come in the form of buttons, menus, box or control on the cursers. All these tools transform the static solutions in quantities similar to the results observed in real experiment, dynamically changing when varying one of the physical parameters. Of course all these tools give us a lot off opportunity in achieving a real hands-on experiences for both the experimental and the numerical point of view. Indeed adding widgets into graphics is equivalent to adding diagnostics in experiences and this is also a good way to push students to become active learners.

Designing a Graphical User Interface (GUI) for an application remains a difficult task and we are not going to develop here the complete steps to achieve this. However there are some procedures that need to be considered which can be roughly summarized in two main steps: the first step is to create a file containing all the elements devoted for interaction with the mathematical function and the second is to convert this file into a language that can be understood by Python. Fortunately the Qt toolkit installed with Python environment provides the necessary material to do that. We have at our disposal the ‘Qt Designer’ to build interactively our interface and the actual version of the command ‘pyuic5’. Figure.4 shows the configuration built for the Young double slit with ‘Qt Designer’

Figure.4 :

‘Qt Designer’ interface used to build the your own GUI application.

‘Qt Designer’, similarly to other software (Visual Basic, Real Studio, …), allows building GUI by simply dragging widgets listed as icons in the left panel of the windows and control their characteristics (name, size, location, …) with the tools in the right panel. We show here as an example the selection of the slider associated with the wavelength named ‘slider_lambda’ (right panel) accompanied by other information given in the yellow part for the other widgets. After putting in place all the physical parameters (b, a, D, λ) we have to connect them with the intensity ‘I’ implemented in the script given above. How to do this? When saving the configuration shown in Figure.4 we generate a file named by the title on the top of the main window, here ‘Ui_DoubleSlit1D’ with the extension ‘.ui’. This code is translated into Python running on the terminal by the following command ‘pyuic5 -x Ui_DoubleSlit1D.ui -o Ui_DoubleSlit1D.py’. This generates a program in Python language that can be imported as any kind of functions or libraries into our previous script. This is shown in the script bellow where we only exhibit the major additions to the program.

Finally the result of this second version is illustrated in Figure 5 showing how the light intensity will vary when manipulating the different widgets displayed on the left panel.

Figure.5 :

‘Qt Designer’ interface used to build the your own GUI application.

Indeed, the program has increased in complexity but let us focus on the points we are concerned with, i.e. teaching and interactive learning. So we can see here how the values can be varied using the widgets for the physical parameters (a, b, D, λ) instead of the fixed value adopted in the previous static script. We recognize for example, in Figure.4 ‘slider_lambda’ associated with the ‘lamda’ variable for the wavelength. The lines starting with ‘@pyqtSlot’ in the script insure the new computation of the intensity function ‘I’ each time one of the widgets is manipulated. So we can see, from this Young double slit example, how we can interactively control any mathematical expression by taking the control of its parameters.

Otherwise and as we noted the implementation of the interface shown in Figure.4 requires numerous operations such as the line ‘from Ui_DoubleSlit1D import Ui_mainWindow’ inserted in the header but also the need to define: a _main_ routine, a ‘DoubleSlit’ class and two functions ‘_init_’ and ‘fig1’. This part is perhaps the most subtle and delicate to transmit to teachers and students because we have to insert them manually. The only way out here is to convince participants to firstly accept these notions without understanding all their meanings because our main goal deals with optics and physics and not the subtleties of writing software. The content of the file ’Ui_DoubleSlit1D.py’ is also very complicated but we can consider it as a black box. Nevertheless, for all these topics (and more) we can find many documents and guides online^16,17,18.