A Mass Toy - The Documentation
The Masstoy applet is now in test use.
This applet allows you to make theoretical experiments with neutrino
mass matrices. Especially, you can explore the consequences of non-trivial
many-flavour mixing scenarios.
Presently it serves as an educational toy - the results do not meet the
requirements of scientific rigor.
Mass Toy has been written with the Java 1.1 specification, and compiled
with JDK 1.1.6.
Java 1.0 is no longer supported, the last version compliant with 1.02, Mass Toy 0.41
is available as a zip file.
Features that work:
- Insert the mass matrix, component by component. Only real numbers allowed.
- Select Symmetrize from the menu
- the mass matrix will be automatically symmetrized.
- Choose Dirac or Majorana masses.
- Click the checkbox to add right-handed neutrinos.
- Select Diagonalize from the menu.
- Study the results.
- To study the consequences for observable phenomena in different part of the
universe chose the appropriate menu item.
- Mass matrix is diagonalized correctly, up to machine accuracy.
- Checks for the lab limits for masses, including Majorana mass.
- Compares with some neutrino oscillation searches
- Makes predictions of solar and atmopsheric neutrino fluxes and compres them
with the experimental results.
- Vacuum oscillation for solar and atmospheric neutrinos.
- MSW effect.
Drawing is multithreading -you see the plot appearing gradually as more points
are computed. Accuracy better than 10 %.
- Relic neutrinos and dark matter.
- Supernova neutrinos - observable spectrum, implications to explosion and nucleosynthesis.
- Right-handed neutrinos. Try also see-saw.
- Zee model
- Magnetic moments
- Neutrino decays
- The three boxes give the electron neutrino disappearance probability,
the probability for the conversion from muon neutrino to electron neutrino,
and the conversion probability from the muon neutrino to tau neutrino,
as a function of L/E.
- The boxes correspond to the sensivity of the experiments. The vertical lines show
approximately the range of L/E that can be explored, and the horizontal line gives
the bound for the average probability. In most experiments the sensivity
is not linear in L/E, so that within the explorable range the true bound may be somewhere
below or above the depicted line. Nevertheless, if all your points are well above or below
the boundary line, you may assume that your model is forbidden or allowed.
If the points are close the line, you should take this as an invitation to investigate
it in more detail using the criteria published (or unpublished) by the experimental collaboration.
- The black crosses are the predictions (with oscillations),
and blue or yellow bands are the
experimental results, with one sigma errors.
- The threshold energies of solar neutrino experiments are displayed as
different shadings in the solar neutrino spectrum graph.
- The blue and white rectangle is the status bar. The experimental results
are displayed when all points are calculated. The first curve is not averaged,
hence it may display some articifial oscillatory features.
- A crude Chi squared is given.
- The first plot is the double ratio as a function of L/E measured in SuperKamiokande.
- The next plots compare the simulation with the experiments.
- The black crosses are the predictions (with oscillations),
and blue or yellow bands are the
experimental results, with one sigma errors.
- A crude Chi squared is given.
- Uses a distorted Honda et al model for the atmospheric flux. This is not very well
adapted for this purpose, but the experimental groups have not revealed the
details of the calculations and predictions they use.
- The plot gives the neutrino fraction in the universe relative to the critical density,
that is the usual omega, as a function of the normalized hubble constant.
- Neutrino decays are taken into account
- The black lines show omega for h=67 ± 6, and the green area is the respective
two sigma region.
Early universe: completely mishandled so far.
- The central plot gives the neutrino spectra observable at terrestrial detectors.
The three curves correspond to electron neutrinos, electron antineutrinos,
and the average of all active neutrinos (for neutral currents). Note logaritmic scale.
- The left canvas displays the electron fraction at the distance of 1000 km.
- The right canvas displays qualitatively the effects on the power of the explosion.
- The rightmost canvas is not activated - it should display the energy loss from
the supernova core, compared with the standard case.
- Be aware that the results are based on a simplified astrophysical model.
Other models may give different results - the chosen model may not be any better than
any other model. Note also that the neutrino spectra and the stellar profile are not
constant - the displayed results give a snapshot at some epoch within the first second
after the bounce.
- feedback effects not accounted for - conversions from electron (anti)neutrinos to sterile
neutrinos may be erratic for masses above eV scale.
- If you understood the above, you already know that the results are only order of magnitude
In my machine (PP180), the diagonalization of the mass matrix is immediate, as are
all the other tasks, except the MSW conversions for solar neutrinos. The matter
conversions typically give useful results in a few seconds, to study all 500 points
takes usually less than a minute. For very complicated mass matrices more time
is needed. On the other hand, with my home machine (486/33) diagonalization
takes several seconds, and the MSW conversions takes minutes.
The code is designed to be loadable class by class. It should start running
when the first class is loaded, and the rest of the classes may be loaded
on demand. Nevertheless, many systems load all classes upon initiation of
the program, even if those classes are never needed (Probably this feature is
related to Just In Time compilers). At best, this improves
the performance, since new classes are already loaded. At worst the loading
of unnecessary classes takes lots of time before the execution can start.
Description of the code
Uses a Frame class to display the input and output panels.
Actions and options are chosen from the menu.
Diagonalisation of the matrix
The matrix is diagonalized by Jacobi rotations. The routine
is fast and accurate, and usually converges by less than ten
Inside the integration of the neutrino wave penetrating a star,
a lighter first order diagonalization routine is used. Although
it does not diagonalize the matrix completely, there will not
be any accumulated error due to that.
Vacuum oscillations are treated by the usual oscillation formula,
taking the average for rapid oscillations.
Matter effect is modeled by a numerical integration over the Sun.
The code has been optimized for speed rather than accuracy.
It has been designed for a numerical accuracy of 2 %, and at least
for solar neutrinos its accuracy is better than 5 %, for most parameters.
In the integration, the neutrino wave functions is divided to the
absolute value and the phase. This allows to treat the absolute value
accurately enough, while the evolutions of the phases can be computed
by lighter accuracy.
The many component neutrino wave is always taken to be in the local
eigenbasis of the medium. While the eigenbasis changes, the effective
hamilton operator acquires non-diagonal components proportional to the
derivative of the mixing matrix. Compared to the straight-forward integration
in a fixed basis, the eigenbasis method provides better accuracy,
since there is no unnecessary oscillation among the integration variables.
Most runs require O(100) steps, though the penalty is that tediuos
matrix multiplications have to be done at each step.
Peculiarly, the code is fastest for full adiabatic conversions, while it is
very slow for very non-adiabatic conversions by rapid change of the
potential. As such cases lead to very small conversions, the code tries
to detect abrupt crossing of the resonance, to pass it smoothly.
The MSW routine is run as a separate thread.
The plotting is also its own thread. Unless you have a multiprocessor mahcine,
the threads are not run concurrently. However, this provides the essential benefit
of seeing how the integration proceeds, until all about 144 runs have been
computed. Often the first points are enough to give an image what is going on.
Later points add accuracy.
Sometimed the solar screen is not updated regularly. To force the update,
repress the solar neutrino button, or minimize and maximize the browser window,
or do something similar, depenping on the platform.
The finite size of the neutrino production region is accounted for by taking
an average of 17 different initial points. Angular distribution is still incomplete.
For the Sun and the solar neutrinos the models and data by John Bahcall is used. (BP 98)
The predictions for the experiments are calculated by computing the expected
neutrino fluxes within the sensitivity of the experiments. The code uses
tabulated cross sections and solar fluxes, sums over the energy spectrum,
and takes the neutral currents into account in water detectors.
Other parts of the code
Nothing special, all straight forward.
Hardware and software requirements
The applet has been designed to be run with the following minimal configuration:
It probably works for less than minimal machines, but then I cannot guarantee
that it is useful for anything. (I do not guarantee it anyway, so never mind).
More power is desirable for excessive studies of complicated matter conversion
scenarios. A PC with Pentium Pro, or a risc-based workstation is recommended.
- color monitor with the resolution 800*600
- powerful processor (P150 or like) and lots of memory (16-64, depending on OS)
- at least 32-bit multithreading operating system with a graphical user interphase
- up-to-date Java 1.1 enabled web browser
- optimized JIT compiler (especially for studying MSW effects)
Note that a good software is essential to run the Java code. Outdated Java browser
without a good JIT compiler can freeze even a supercomputer.
Power users may load the classes on their disk and run them directly.
A good java applet viewer may perform better than web browser,
and some systems allow a compilation to machine code.
The program runs also as a standalone application.
Load masstoy.zip, unzip it
into a directory MassToy and try
java MassToy.Masstoy, (in the parent directory).
This procedure may be machine dependent, consult
the documentation of your system.
Known bugs, misfeatures or limitations
- The 6-6-component of matrices is not displayed. Probably a bug of the compiler.
- Neutrino conversions in supernova may freeze or diverge for certain parameters.
(probably fixed in 0.39/0.40)
- In some rare cases the MSW routine may miss or mishandle a resonance - occurs mostly
for complicated 4 flavour supernova simulations, resulting in weird neutrino spectra.
- If you do not have three massive neutrinos an exception will occur.
(fixed in 0.41)
If you get an error message on your Java console that is not listed above,
please send me a message
explaining the conditions in which the error occurred.
- Atmospheric neutrino model very poor - the code has been calibrated with
some artificial parameters.
- No CP-violation - only real matrices allowed.
- Checks for many laboratory constraints not done yet.
- Astrophysical constraints are rather crude.
- Phenomena in the core of supernovae not yet studied. Also other supernova
code is very primitive.
- Early universe not simulated either.
- No links to references.
- Feedback effects in neutrino conversions ignored.
- No matter effect for solar or atmospheric neutrinos passing earth.
- Day night effects for solar neutrinos not simulated.
- Some symbols inconventional or inexistent, since few systems support full Unicode.
- This is probably a feature of the operating systems, but many unix machines
do not reload the java classes unless you reboot the computer.
- Printing does not work. This is a security feature of Java: applets loaded
from the web cannot send anything to a printer.
- Probably does not work at all with some Microsoft products, because they contain
too many bugs. Sorry, but I cannot do anything for this before Bill fixes his part.
- Does not take majoron (or any other scalar) couplings as input
- The statistical analysis (chi squared) is very primitive and not compatible with other
published values. For example it does not
treat the (correlated) systematic errors correctly.
The applet has been tested in the following platforms (not necessarily the newest version):
- Java applet viewer (Java 1.1.6) under OS/2 Warp version 4:
works well and looks fine
- Netscape 2.02 under OS/2 Warp version 4 : works flawlessly, runs very fast and looks fine
- Netscape 4.05 beta under OS/2 Warp version 4 : the browser crashes with all Java applets .
- Netscape 4.04 under Linux: Works and looks almost OK. Via X terminal very slow.
- Netscape 4.04 for Windows 3.1: Works, but is dead slow. Graphics occasionally distorted.
- Netscape 4.05 for Windows 3.1: OK but very slow.
- Netscape 3 in PowerMac: works, but is very slow.
- Microsoft Internet Explorer 3.0 for Windows 3.1: Java crashes by start.
- Netscape 4 at Silicon Graphics: started OK but freezed at some point.
- Microsoft Internet Explorer 4 under Windows 95: works quite well and fast.
Minor defects on the look and feel.
- Netscape 3.01 under Linux RedHat4.1: works
The applet looks very ugly now. The ugliness is a way to get around of bugs or features
in some systems. (Do not believe the marketmen who claim that Java is a platform-independent
language. Nothing is idependent on the platform, nothing, believe me.)
Some tips and hints
If the program does not run, check the following:
- You have Java correctly installed in your system.
- You have a web browser that supports Java (Read the documentation - if it does
not explicitly mention Java, it does not support Java.) Recent versions of Netscape are good.
- You have not turned on disable java in options or preferences of the browser.
- If it fails to run in your web browser, load the zip file and run it either as a standalone
java Masstoy or in your applet viewer (
you need to save tt-mass.html in your disk).
- If the performance is very poor, check whether you have an outdated version of Java.
- Your client may be still loading the program over the network - the code is long and the internet it slow.
The history :
- 0.01: first version released to the net. Diagonalised the mass matrix.
- 0.02 - 0.11 : early evolution versions, added more features.
- 0.12: fixed solar neutrinos.
- 0.13: minor updates on data, some corrections of the code and redesign of the look.
- 0.14: right-handed neutrinos included; omega-h-plot for dark matter; bugs corrected.
- 0.15: included neutrino conversions in supernova; MSW code refined.
- 0.16: corrected a persistent bug in MSW-code, small improvements here and there.
- 0.17: minor improvements here and there, some enhancements of the user interface,
and cleaning of the code.
- 0.18: major changes in the interface: the Applet runs now in a separate Window,
and it is controlled by menus.
- 0.19: minor improvements in the interface. Removed an eternally appearing exception.
- 0.20: Changes in the internal structure - supposed to load faster. Minor changes
in the interface.
- 0.21: Some restructuring of the code. Input enhanced - Zee model included.
- 0.22: Cleaning of code. Added electromagnetic properties. Some enhancements of input -
demo mass matrices (quite arbitrary). New version (bug fix) of the Java compiler used (still 1.02 level).
- 0.23: Can be run as a stand-alone application. Solar neutrinos refined. Group exception fixed.
- 0.24: Some bugs fixed (matrix diagonalisation, supernova jams, nutau expts).
Enhanced electromagnetic properties. More demo values added.
Some minor modifications of the interface.
- 0.25: Added neutrino decays and status bars for solar and supernova computations.
- 0.26: Some bugs corrected. Added comparison to Chooz.
- 0.27: Lots of bugs corrected, interface enhanced.
- 0.28: Some minor bugs corrected, code restructured (little effect for end-user). Compiled
with a new Java 1.1.4 compiler. Code still at Java 1.02 level.
- 0.29: Minor bugs corrected, major rearrangements of the code. Added an inoperative plot.
- 0.30: Substantial improvement on the performance - starts much faster, loads classes in a thread.
- 0.31: Major improvements on the performance during the initialisation. Now starts
'immediately', after loading the first classes. Actual efficiency depends on the system,
and the state of the network, though.
- 0.32: Corrected neutrino decays. Now calculates the relic densities with all decay modes,
including three neutrino decays. Added an empty canvas for radiative neutrino decays.
- 0.33: Minor bugs corrected. Major changes in code with no effect for the end user.
- 0.34: Major parts of code rewritten, but the only visible effect was the appearance of new bugs.
Never released to the public.
- 0.35: Corrected the bugs. MSW routine rewritten for better performance. Autodocumentation.
- 0.36: Solar neutrino experiments fixed and updated to results reported at Neutrino 98. Compiled
with Java 1.1.6.
- 0.37: Solar neutrinos refined. Added a primitive chi squared analysis.
- 0.38: Atmospheric neutrinos completely recoded, with a comparision to SuperKamiokande.
A minor solar neutrino bug fixed.
- 0.39: Fixed a bug on MSW conversions, appearing for supernova neutrinos.
Atmospheric neutrinos refined.
- 0.40: MSW routine enhanced - still far from perfect.
- 0.41: Fixed an input bug. Tuning of MSW continues.
- 0.42: code migrated fully to Java 1.1 level.
Some changes in the user interface, more to come.
Interchanged the notation for experimental and theoretical
values at atmospheric neutrino plots.
- 0.43: more visual changes in the user interface.
Several bugs fixed in input and display.
- Intelligible help features and explanations.
- Better predictions for the atmospheric neutrino fluxes.
- Will handle neutrinos in early universe, especially the effects on nucleosynthesis.
Do not hold your breath with this, however, it is a more elaborate task than
any of the present contents..
- User interface will be redesigned.
- Consequences to structure formation
- Radiative neutrino decay and photon background
- More models for neutrino masses
- Exotic decay modes, e.g. majorons.
- Better simulation of supernova dynamics.
- More powerful and more accurate MSW routine.
- The code will be made more intelligible, to allow it to be maintained more easily, and more compact,
to allow faster loading over the network.
I would appreciate receiving feedback how this applet performs in different platforms.
If it runs or not in your host, send me mail.
Back to the Ultimate Neutrino Page