loom
A framework to generate and analyze spectral networks, including a GUI based on Tkinter
and a web frontend based on flask
. loom
is written in Python, Javascript, and C++.
loom
has the following functionality.
phase
to None
.In addition, loom
contains a web frontend that drives a WSGI application, which can be loaded from any web server that supports WSGI applications, including Apache. To see how the WSGI application looks like, visit
stable_*
is the branch to use for the study of spectral networks, master
is a developmental branch that may contain up-to-date but unstable features.
loom
web UIloom
can be found at
/
, that is, the full url of /config
is http://het-math2.physics.rutgers.edu/dev_loom/config./config
to set a configuration to run loom
on the web.A_2
. For example, to generate an D_4
spectral network in a spinor representation, choose the options in the following way:
loom
but just a convenient note to understand the data without loading it onto loom
.Python
dictionary of the differentials that specify a class S theory. The default configuration corresponds to
phi_2(z) = v_2 (dz)^2
phi_3(z) = (v_3 + z^2) (dz)^3
where v_2
and v_3
are complex parameters whose numerical values are to be specified in Parameters of differentials. The differentials are intepreted as SymPy
expressions, therefore they should follow the syntax of SymPy
. For example, an explicit representation of multiplication using *
is necessary. Python
dictionary of the complex parameters that appear in the definition of the differentials. But for the convienience of users an unusual format of using =
instead of :
is allowed, i.e. {v_2 = 1.0, v_3 = 1.0}
works the same as {v_2: 1.0, v_3: 1.0}
.Python
lists, and the entries are interpreted as SymPy
expressions. Note that the locations should be the same as those specified by the differentials, and changing just the entries here does not change the spectral network itself but results in a spectral network generated in an incorrect way. In the future this information will be automatically obtained from the differentials.loom
grows S-walls from their seed, and at the end of each iteration loom
finds the joint of S-walls and the seed of new S-walls from the joints. This parameter specifies how many iterations loom
will go through, therefore a larger number of iterations will result in a longer run of loom
. It's a good practice to start with Number of iterations = 1
, so that no S-walls from the joints will be grown to have a rough picture of a spectral network, because there is a possibility that the number of joints can be huge even after just one iteration and the running time can be uncontrollable.loom
is starting with a small mass limit.[theta_i, theta_f, theta_n]
, which results in theta_n
number of spectral networks from theta_i
to but not including theta_f
. That is, [0, 3.14, 4]
generates spectral networks at 0
, 3.14/4
, 3.14/2
, and 3.14*(3/4)
.\theta = 0.01
to \theta = 3.14
..ini
file on your local machine.loom
with the specified configuration.SL(2, \mathbb{C})
transformation on the UV curve. However it is not fully implemented yet.system_of_eqs
, discriminant
, from_branch_points
, and manual
.system_of_eqs
. For the detail of the methods please see geometry.py.from_branch_points
, you need to provide the locations of the branch points on the z-plane as a Python
list of SymPy
expressions in Branch points, whose example is given in the default configuration. When both system_of_eqs
and discriminant
methods fail to give answers, use this method as this is more robust than those two because the locations of branch points are manually provided by you, but more convenient than manual
method because you don't have to find the x
roots by yourself.manual
, you need to provide the locations of the ramification points in Ramification points as a Python
list of (z_i, x_i)
, each of which is a sympy
expression. This is the most robust method, simply because you already did all the calculations for finding the locations of the ramification points and all loom
does is finding the ramification point index, or the multiplicity of the x
root over a branch point.None
, the ramification point finding method is automatically set to manual
.None
, the ramification point finding method is automatically set to from_branch_points
.loom
adpatively chooses as the size of one step when solving the differential equation for S-walls.loom
will stop evaluating the differential equation as the points are singular for the differential equation..png
, reset the zoon and the displacement, etc.loom
is actually done, this is mostly for the purpose of debugging.1.0
, in radian.Python
list, such as [0.01, 3.14, 10]
, which specifies the start, the end, and the number of additional phases.Python
dict, such as {'single': [1.0, 2.0], 'range': [0.01, 3.14, 10], [1.53, 1.55, 10]}
, where single
is a Python
dict
of single phases and range
is a Python
list of Python
lists, each of which specifies a phase range. loom
will automatically generate a list of phases out of this dict
and remove any duplicate, so you don't have to worry about excluding duplicate phases.loom
for the extension. \plot?data=data_name
for data named as data_name
.loom
data on your local machine, but you need loom
to load the data.loom
on your local machine to see this plot as long as it is connected to the internet.loom
loom
is expected to run on a Linux system. Although loom
does not require any platform-specific library and therefore should run on any platform that runs Python 2.X in principle, it usually runs into a platform-specific problem when run on a platform other than Linux; for example, on Windows it has an issue with multiple processes, and on Mac it has an issue with TKinter GUI.
To run loom
's web frontend, the preparation is more involved. Please contact https://github.com/chan-y-park for the detail.
loom
webmain.wsgi
.
Python
package.webmain.wsgi
there will be a local web server running and listening to port 8888
. Open your favourite web browser and go to localhost:8888/config
for the configuration page.webmain.wsgi -p xxxx
where xxxx
is a port number, for example 9999
. Then go to localhost:xxxx/config
.loom
crashes, there can still be a Python
process running. You need to manually kill the process by first finding its pid
using for example ps -aux
and kill -9 xxxxx
where xxxxx
is the pid
of the Python
process.pdb
while running loom
using the web UI is not recommended, as it usually won't work unless you carefully place pdb.set_trace()
in an appropriate location. The reason is, as all UI frontends do, loom
runs as a child process behind a parent process driving the UI
, and using pdb
on loom
only stops the loom
process, which the parent process sees as the child not responding to itself.loom
for whom knows about Python
is running it using IPython
and Jupyter
. As an example, see how_to_run_loom.ipynb for the Python
code and how_to_run_loom.html how it looks like when it is run successfully.gmain.py
is an executable Python script that launches a GUI version of loom
.loom
module.loom
directory, start the python interpreter.>>> import loom
>>> config = loom.load_config()
>>> config = loom.load_config('default.ini')
.LoomConfig
that contains all the configuration information.>>> data = loom.generate(config, phase=1.0)
>>> data = loom.generate(config)
>>> spectral_network_plot = loom.plot(data)
d
to delete all the displayed labels.>>> loom.save(config, data, data_dir='data/name/', make_zipped_file=True)
config.ini
, data_*.json
files at data/name/
directory, and make a zipped file of the directory.data_dir
is not given, this opens a directory dialog window to select a directory to save config.ini
and data.mose
.>>> config, data = loom.load()
(config, data)
.>>> config, data = loom.load('data/name/')
.