1. Introduction > 1. Getting Started
Pykat
Author: Daniel Brown
import pykat
%matplotlib inline
This section aims to outline both the philosophy of Pykat and provide an overview of how it intends to work.
Pykat is an object-orientated Python wrapper for the Finesse binary. It aims to simplify the usage of Finesse for more complex simulation tasks. For example:
Interacting with Finesse to run more complicated simulation tasks using just the builtin plotting and output functionality quickly becomes limiting. In such cases it is usual to want to loop, repeat or modify simulations as you experiment and better understand the problem. Pykat has evolved to make such tasks easier.
There are three distinct features in the Pykat-Finesse interaction that will be referred to throughout this description:
The model of the interferometer is that which you design and generate using Finesse commands. This will be a collection of optical components that represents the system in general. It does not assume anything about what data will be produced or detectors used.
Once a model is created you can design the type of Simulation that you wish to run. This requires you to first decide what type of output you want to see, thus what detectors you need to add to extract optical, mechanical or other values. Along with this the changing variable must also be set using the xaxis setting.
Finally, a simulation is taken and you run it. This takes all the settings and configuration of the simulations and passes it to the Finesse binary. This then runs the simulation and generates various data files containing the output result. Pykat parses these data files into more friendly formats for the user to enable plotting or further processing of the output.
It is important when using Pykat, Python and Finesse to have a structured workflow and a proper understanding of what each of these elements do. By doing this you should be able to keep your scripts clean and usable.
Firstly, the most important object of pykat is the kat object. The name kat was chosen as this is the name of the Finesse binary.
This object contains all the model details and describes one simulation. Thus, it is worthwhile to perceive this kat object as a single Finesse file that you might write by hand - except that this object handles the writing, running and processing of the output of the final file for you. By interacting with this object and its contents you alter the Finesse file that will be run.
You can build your model and setup your simulation in two ways: By entering the standard Finesse commands (either as strings or by loading a pre-written Finesse file) or by creating directly creating pykat objects. We will concentrate on the first option here.
We start by creating an empty model like so:
kat = pykat.finesse.kat()
In its current state this kat object doesn't do anything. You can load an existing Finesse file, if you have one, into the object with:
kat.loadKatFile("cavity.kat")
Here a simple file consisting of a laser and a Fabry-Perot cavity has been added. You'll notice that no output is shown here. If there is an error in parsing any of the commands in a file these will show up at this stage.
This Finesse file contains a model of a Fabry-Perot cavity and the commands to simulate a scanning one of the mirrors to output the circulating power in it.
kat-object?¶For (nearly) every Finesse component, detector and command there is an equivalent Pykat object. When a Finesse file is read each line will be parsed for the type of object and its parameters to load into the kat object. For example, a laser is described by the object pykat.components.pykat.components.laser.
There are three main dictionaries that store the three different types of Finesse objects: components, detectors and commands. The key to dictionary is the name of the component, detector or command and the value is the object itself. You can see the contents by printing them:
print(kat.components)
print(kat.detectors)
print(kat.commands)
We can see here we have a laser called l1, mirrors m1 and m2, a space s1, a single pd (DC photodiode) detector circ and an xaxis command.
IMPORTANT NOTE: Do not add/remove/change the dictionary enteries yourself!! Doing this will break various internal connections and will just stop it working.
If you want to get hold of a particular object you can do it in two ways:
kat.components["m1"]
kat.m1
Note that the object reference, something like 0x10771bd30, is the same in both cases. So we can see we are accessing the same object.
The second method is the recommended way when writing your scripts and know the name of the object, as this is less typing. It also allows for auto-complete to work on the object. So when typing code you can type kat.m1. then press the tab key to see all the possible parameters.
The first method though is still useful in cases where you need to access objects when you have the name in a string. A typical example might be looping over objects by their name:
for n in range(1,3):
m = kat.components["m"+str(n)]
print(repr(m)) # Here we print the object info
Once the objects have been added to the kat object we can change their parameters easily. For example, we can change the reflectivity and transmistivity of the input mirror with:
kat.m1.R = 0.6
kat.m1.T = 0.4
Likewise, we can quickly see what the value of particular parameters is:
print(kat.m1.R)
If using Pykat, or IPython, then you have access to auto-complete features on objects. This is paritcularly handy for exploring Pykat objects and their properties. You can easily see the options available by typing . after the object and pressing the tab key. For exmaple:
Pykat is just a set of tools that produces a complete Finesse file and then runs it. It is sometimes useful to be able to print the actual Finesse file that is run to double check you have the correct file or to better understand some result you were not expecting.
To do this we just print the kat object we are interested in:
print(kat)
kat.s1.L = 10
print(kat)
Here we can see all the components, detectors and commands for simulating the cavity scan to output the circulating power. Then when we change some parameter we can also see how the length of the space s1 changes.
Running the simulation is straight forward:
out = kat.run()
If all has worked then it will just print how long it took to run. The out object contains the output of the simulation. The output will consist of arrays for each of the detectors you include in your simulation.
The detector output is accessed via its name with the output object:
print(out["circ"])
The output object contains a variety of information about the simulation. A summary of the data it contains can be found with:
out.info()
Or we can see what Finesse commands were used to generate this data:
print(out.katScript)
Or you can quickly get the xaxis values and make a plot of your choosing:
import pylab
pylab.plot(out.x, out["circ"])
Or if you want something quick you can quickly use the builtin plotting (More example of which can be found in the plotting example notebook):
fig = out.plot()
A common requirement for more complicated simulations is the ability to change something in the model and re-run the simulation. Typically this requires various xaxis commands and detector combintions to get the output you desire. The way this would be done in Finesse would be if you had separate Finesse files for each of the simulations you wanted to run. Or you could have one big file and comment/uncomment particular lines - either of these become troublesome for complicated changes.
In Pykat we deal with objects. The recommended workflow is if you keep a single .kat file that contains you base model, or commands that will be common to the majority of your simulations. From this base model you then copy it within Pykat and then add in the simulation specific commands you require. For example:
basekat = pykat.finesse.kat()
basekat.loadKatFile("cavity_base.kat")
kat1 = basekat.deepcopy()
kat1.parseCommands("""
# Finese code for this one type of simulation ...
""")
kat2 = basekat.deepcopy()
kat2.parseCommands("""
# Finese code for this another type of simulation ...
""")
# Then run it: out1 = kat1.run()
# And the next one: out2 = kat2.run()
With these copies we can do whatever we like, add and remove new optical components, change parameters, etc.. You just need to be careful that you keep track of which kat object has what changes.
This will be a common pattern used throughout these series of notebooks. Another useful pattern is when making function that accept a kat object. For example, we might want to make a function that simulates the power in a cavity when the mirror is tuned. This function will take the model, the mirror to move and which node to get the power from, compute the result and return the values. This however, will not alter the original kat object, so we can continue using it for something else.
def simulate_intracavity_power(kat_in, mirror, node):
kat = kat_in.deepcopy()
kat.parseCommands("""
xaxis {mirror} phi lin 0 180 180
pd circ {node}
""".format(mirror = mirror,
node = node))
out = kat.run()
return out["circ"]
basekat = pykat.finesse.kat()
basekat.loadKatFile("cavity_base.kat")
simulate_intracavity_power(basekat, "m2", "n2")
This notebook has introduced the basics of Pykat and some recommended workflows. Obviously, you are free to try out other methods, but those shown above in our experience have been the most useful.
It is important to remember with Pykat that it is just a Finesse file generator. To use Pykat effectively you still need to understand the underlying principles behind Finesse and how to generate these files yourself. If you don't have this experience then you are likely to end up confused when things do not run as expected!